home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / DSHJ2 / HANDLERS.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  111.5 KB  |  4,644 lines
  1. /**************************************************************************/
  2. /*  FILE:  HANDLERS.C        PROGRAM TITLE: DeskSET II Alpha Version   */
  3. /*  Date Created: 12/15/87                          */ 
  4. /*  Last Modified: 06/30/89                          */
  5. /*                                      */
  6. /*  Description: MENU, MESSAGE, EVNT_MULTI HANDLERS              */
  7. /*  Routines:                                  */
  8. /*        o front_end()       - Initializer                  */
  9. /*    o initialize()      - Initialize variables              */
  10. /*      o event()            - Event Multi                  */
  11. /*    o hndl_keybd()        - Event Keyboard Handler          */
  12. /*      o mesag_handle()    - Event Message Handler              */
  13. /*    o menu_handler()     - Menu Event Handler              */
  14. /*    o button_handler()     - Button Event Handler                */
  15. /*    o do_nada()        - Handler to select a region          */
  16. /*    o screen_clip()        - Set Screen clipping              */
  17. /*    o scrn2clip()        - Another clip setting routine - PADJCNT  */
  18. /*    o poly_handler()    - Secondary poly draw handler          */
  19. /*    o button_end()      - Concludes Button and poly handler       */
  20. /*    o check_region_ptr()    - checks for active graphic or text region*/
  21. /*    o check_only_blit()    - check if all we need is a blit...      */
  22. /*    o do_delregion()    - Delete the currently selected region      */
  23. /*    o do_unlinkreg()    - Unlink the current text region      */
  24. /*    o do_delpage()        - Delete the current page          */
  25. /*    o do_move_region()    - Handles moving a selected region      */
  26. /*    o check_boxes()        - handles 8 boxes for scaling region       */
  27. /*    o do_rule_mark()    - Handles the ruler markers          */
  28. /*    o update_repel()    - Repels new region for flowing of text      */
  29. /*    o snap_to_grid()    - snaps vertices to a specific grid      */
  30. /*    o snap_mu()        - snap in machine units              */
  31. /*    o do_edit_prim()    - Select w/ right button a primitive      */
  32. /*    o calc_prim()        - Calculate outer boundary of primitive   */
  33. /*    o edit_prims()        - Move and Size Primitives          */
  34. /*    o check_prim_box()    - Size a primitive              */
  35. /*    o recalc_region()    - Recalc region bndry after editing prim  */
  36. /*    o move_prim_box()    - move a primitive within a region      */
  37. /*    o inside_primitive()    - check if clicked within a primitive      */
  38. /*    o hndl_icons()        - handle left icon panel selections      */
  39. /**************************************************************************/
  40.  
  41.  
  42. /**************************************************************************/
  43. /* INCLUDE FILES                              */
  44. /**************************************************************************/
  45. #include "define.h"
  46. #include "gemdefs.h"
  47. #include "deskset2.h"
  48. #include <obdefs.h>
  49. #include <osbind.h>
  50. #include "alert.h"
  51. #include "dbase.h"
  52.  
  53. /**************************************************************************/
  54. /* DEFINES                                  */
  55. /**************************************************************************/
  56.  
  57. #define max(x,y)   (((x) > (y)) ? (x) : (y))
  58. #define min(x,y)   (((x) < (y)) ? (x) : (y))
  59. #define MICRON   319
  60. #define NULLPTR  0x0L
  61. #define MIN_MEM_TO_RUN 5000L
  62.  
  63. /**************************************************************************/
  64. /* EXTERNALS                                  */
  65. /**************************************************************************/
  66. extern int ptsin[];            /* PTSIN array              */
  67. extern char rscerr3[];            /* Delete Regions Alert Box text  */
  68. extern char del_page[];
  69. extern char delregion[];
  70. extern char quiter[];
  71.  
  72. extern int (*funcs)();            /* Drawing Primitive Functions    */
  73. extern long find_region();        /* Function - Find Region       */
  74. extern int nada();            /* Default Drawing Primitive      */
  75. extern int poly_draw();
  76. extern long getf_scaninfo();
  77. extern long getn_scaninfo();
  78. extern long prev_aregion();
  79. extern int scrntomu();
  80. extern int recalc_txtptrs();
  81.  
  82. extern OBJECT *ad_menu;            /* OBJECT for menu bar etc.       */
  83. extern OBJECT *ad_deskset;        /* OBJECT for ABOUT dialog box    */
  84. extern OBJECT *ad_paths;
  85. extern OBJECT *adpagedef;        /* page type dialog box          */
  86.  
  87. extern int dummy;            /* well, dummy...          */
  88. extern int hpage_size;            /* horizontal and vertical page   */
  89. extern int vpage_size;            /* size in Machine Units (MU)     */
  90. extern int view_size;            /* Current scaling size-ACTUAL etc*/
  91. extern int prev_size;            /* Previous Scale Size...      */
  92.  
  93. extern int curr_page;            /* Current Page Number displayed  */
  94.  
  95. extern unsigned long region_ptr;    /* Pointer to Region in STructure */
  96. extern unsigned long gl_region_ptr;    /* Ptr to Current Active region   */
  97. extern unsigned long gl_grregion_ptr;   /* Ptr to current graphic region  */
  98.  
  99. extern int shandle;            /* screen workstation handle      */
  100. extern int mhandle;            /* Preview Buffer Driver Handle   */
  101. extern int xor_handle;            /* Secondary Screen workstation   */
  102. extern int prev_handle;            /* Preview window handle.      */
  103. extern int rule_handle;
  104.  
  105. extern int txt_handle;
  106.  
  107. extern GRECT work;            /* GRECT of work area of window   */
  108. extern GRECT pwork;            /* Preview GRECT Work Window      */
  109. extern GRECT dpwork;
  110.  
  111. extern int pagew,pageh;            /* page width and height (Pixels) */
  112. extern int opwidth,opheight;
  113.                     /* Note: Size is for current scale*/
  114.  
  115. int rect_in_mu[4];            /* x1,y1,x2,y2 of current region  */
  116.  
  117. extern int mode_flag;            /* Outline/Solid Mode           */
  118. extern char *mode_text[];        /* Info for Prev Window         */
  119.  
  120. extern int write_flag;            /* write white/black flag         */
  121. extern char *write_mode[];        /* write white/black menu text    */
  122. extern char *ruler_mode[];
  123.  
  124. extern int clip_area[];            /* Supposed clip area set         */
  125. extern unsigned long page_ptr;        /* Preview Buffer Pointer         */
  126. extern FDB page_MFDB;            /* Preview MFDB area          */
  127.  
  128. extern int gl_lstyle;            /* Current line styles and fill   */
  129. extern int gl_lwidth;            /* styles...              */
  130. extern int gl_fstyle;
  131. extern int gl_findex;
  132. extern int gl_repel;
  133. extern int gl_repoffset;
  134. extern int gl_repbounds;
  135.  
  136. extern int SH;                /* adjusted point size ht in pix  */
  137. extern int zdevice;            /* index into xdip/ydpi          */
  138.  
  139. extern int BSTATE;            /* Button State...          */
  140. extern BUT_OR();            /* routine to get button state    */
  141. extern long BADDR;
  142. extern int BREAL;
  143.  
  144. extern int  article_flag;        
  145. extern char pathbuf[];            /* path to file...          */
  146.  
  147. extern int cur_scale;            /* current scale          */
  148. extern int cur_primitive;        /* current primitive in RCS #s    */
  149.         
  150. extern struct txtattr gltxtattr;    /* Global txt attributes       */
  151. extern struct txtattr cp;
  152. extern int glgrattr[];            /* Global graphics attributes     */
  153.  
  154. extern int force_draw_flag;
  155.  
  156. extern long get_regart();        /* Return regions article pointer */
  157.  
  158. extern int mboxx1[];
  159. extern int mboxx2[];
  160. extern int mboxy1[];
  161. extern int mboxy2[];
  162.  
  163. extern int count,wmode;
  164. extern int ptsarray[];
  165. extern int xruler_offset;
  166. extern int yruler_offset;
  167.  
  168. extern int hhalf,vhalf;
  169.  
  170. extern int mouse_on;
  171. extern int clipf[];
  172. extern int *clipe;
  173. extern int *icdata;
  174. extern int *primicons;
  175. extern BITBLK *bgicptr;
  176. extern ICONBLK *icnptr;
  177. extern OBJECT *ad_bkgrnd;
  178. extern int ybook;
  179. extern int syres;
  180.  
  181. extern char fntdrs[];
  182. extern int alt_offset;
  183.  
  184. extern long location;
  185.  
  186. extern struct textobj gltext;
  187. extern long get_fregion();
  188. extern long get_nregion();
  189.  
  190. extern char *winfo[][4];
  191.  
  192. extern long get_curreg();
  193.  
  194. extern char *dpath1;
  195. extern char *dpath2;
  196. extern char *dpath3;
  197. extern char *dpath4;
  198.  
  199. extern char *get_edit();
  200.  
  201. extern long getf_aregion();
  202. extern long getn_aregion();
  203.  
  204. extern int reopen_prim;
  205.  
  206. extern short mlink[];
  207. extern long curregion;
  208. extern long sfregion;
  209.  
  210. extern int tmplate_flag;
  211. extern char *template_mode[];
  212.  
  213. extern PAGE *curpage;
  214. extern PAGE *pagehd;
  215.  
  216. extern unsigned char *get_lcmem();
  217.  
  218. extern char *disp_tmpl[];
  219. extern OBJECT *ad_settmpl;
  220.  
  221. extern long MALLOC();
  222. extern ARTICLE *arthd;
  223. extern ARTICLE *curart;
  224. extern long curprim;
  225.  
  226. extern int sxres,syres;
  227. extern long first_aregion();
  228. extern long lmalloc();
  229. extern int free();
  230. extern int force_preview();
  231. extern int do_blit();
  232. extern int dotext();
  233. extern int redraw_laser;
  234.  
  235. extern REGION *create_region();
  236. extern OBJECT *unitobj;
  237.  
  238. extern int sdevm;
  239. extern int zrat;
  240.  
  241. extern int info_what; /* info dialog box - DOC,TEMPLATE,CLIP 0,1,2 */
  242. extern int info_type; /* info dialog box - TEXT,GRAPHIC 0 or 1     */
  243. extern OBJECT *ad_info;
  244.  
  245. extern char pfname[];    /* title for preview window */
  246. extern char basefname[]; /* title for base page */
  247.  
  248. int    *gcurx;                    /* Ptr to mouse x position*/
  249. int    *gcury;                    /* Ptr to mouse y position*/
  250.  
  251. char outdev_alert[] = 
  252. "[1][      Output to:              ][PRINTER|DISK (TDO FILE)]";
  253.  
  254.  
  255. extern long OVMOUSE;
  256. extern long NVMOUSE;
  257. extern KICKAES();
  258.  
  259. extern int circle_draw();
  260. extern int ellipse_draw();
  261. extern int axdpi[];
  262. extern int aydpi[];
  263. extern int zdevice;
  264. extern int scan_xres;
  265. extern int scan_yres;
  266.  
  267. /**************************************************************************/
  268. /* GLOBAL VARIABLES                              */
  269. /**************************************************************************/
  270. GRECT page_area;            /* Page area/work area of prev    */
  271. int done;                    /* event multi flag       */
  272. int evnt_which;
  273. int msg_buff[8];                /* event message buffer   */
  274. int pxyarray[254];
  275.  
  276. GRECT area;                    /* Well, you got me?      */
  277. int newx,newy;                    /* new x and y mouse pos  */
  278. int mode_change;                /* Flag if solid/text mode*/
  279. int button,key;                    /* following used for the */
  280. int oldx,oldy;                    /* evnt_multi calls.      */
  281. int nmx,nmy;
  282. int status;
  283. int pxy[254];
  284. int num;
  285. int aindex;
  286.  
  287. USERBLK   filler[24];
  288. int ob_x[24];
  289. int ob_y[24];
  290. int graph_flag;                /* graphic primitive? 0-no,1-yes  */
  291. int image_status;            /* display images? 0-no,1-yes     */
  292.  
  293.  
  294. sbox0() { pxy[0] = newx; pxy[1] = newy; }
  295. sbox1() { pxy[1] = newy; }
  296. sbox2() { pxy[1] = newy; pxy[2] = newx; }
  297. sbox3() { pxy[2] = newx; }
  298. sbox4() { pxy[2] = newx; pxy[3] = newy; }
  299. sbox5() { pxy[3] = newy; }
  300. sbox6() { pxy[0] = newx; pxy[3] = newy; }
  301. sbox7() { pxy[0] = newx; }
  302.  
  303. amouse0() {*gcurx = pxy[0]; *gcury = pxy[1];}
  304. amouse1() {*gcury = pxy[1]; *gcurx = (pxy[0] + pxy[2])/2;} /* * */
  305. amouse2() {*gcury = pxy[1]; *gcurx = pxy[2];}
  306. amouse3() {*gcurx = pxy[2]; *gcury = (pxy[1] + pxy[3])/2;} /* * */
  307. amouse4() {*gcurx = pxy[2]; *gcury = pxy[3];}
  308. amouse5() {*gcury = pxy[3]; *gcurx = (pxy[0] + pxy[2])/2;} /* * */
  309. amouse6() {*gcurx = pxy[0]; *gcury = pxy[3];}
  310. amouse7() {*gcurx = pxy[0]; *gcury = (pxy[1] + pxy[3])/2;} /* * */
  311.  
  312.  
  313. bmouse0() {*gcurx = pxy[0] - 5; *gcury = pxy[1] - 5;}
  314. bmouse1() {*gcury = pxy[1] - 5; *gcurx = (pxy[0] + pxy[2])/ 2;} /* * */
  315. bmouse2() {*gcury = pxy[1] - 5; *gcurx = pxy[2] + 5;}
  316. bmouse3() {*gcurx = pxy[2] + 5; *gcury = (pxy[1] + pxy[3])/2;}/* * */
  317. bmouse4() {*gcurx = pxy[2] + 5; *gcury = pxy[3] + 5;}
  318. bmouse5() {*gcury = pxy[3] + 5; *gcurx = (pxy[0] + pxy[2]) / 2;}/* * */
  319. bmouse6() {*gcurx = pxy[0] - 5; *gcury = pxy[3] + 5;}
  320. bmouse7() {*gcurx = pxy[0] - 5; *gcury = (pxy[1] + pxy[3]) / 2;}/* * */
  321.  
  322.  
  323.  
  324. int (*da_box[8])() = 
  325.         {
  326.           &sbox0,
  327.           &sbox1,
  328.           &sbox2,
  329.           &sbox3,
  330.           &sbox4,
  331.           &sbox5,
  332.           &sbox6,
  333.           &sbox7
  334.         };
  335.  
  336. int (*adj_mouse[8])() = 
  337.           {
  338.             &amouse0,
  339.             &amouse1,
  340.             &amouse2,
  341.             &amouse3,
  342.             &amouse4,
  343.             &amouse5,
  344.             &amouse6,
  345.             &amouse7
  346.           };
  347.  
  348. int (*bdj_mouse[8])() = 
  349.           {
  350.             &bmouse0,
  351.             &bmouse1,
  352.             &bmouse2,
  353.             &bmouse3,
  354.             &bmouse4,
  355.             &bmouse5,
  356.             &bmouse6,
  357.             &bmouse7
  358.           };
  359.  
  360. int voldx,voldy;
  361. int deltax,deltay;
  362. int txscale,tyscale;
  363. int ruler_flag;
  364.  
  365. int     unit_type;
  366. int xold_mark,yold_mark;
  367. int deferhj;
  368. int show_grids,snap_to_grids,hgridspace,vgridspace;
  369. int clipfull;
  370. int pagetype;                /* current page type          */
  371.                     /* DEFAULT to US LETTER          */
  372.                     /* A4, B5, Letter, Legal,        */
  373.                     /* Landscape A4, Landscape B5,   */
  374.                     /* Landscape Letter, Landscape   */
  375.                     /* Legal (eof)             */
  376.  
  377. /* The page x and y sizes are based in machine units             */
  378. /* 1296 mu per inch horizontally...                       */
  379. /* 1152 mu per inch vertically...                     */
  380. /* All sizes are in inches                         */
  381. /* Paper sizes are:    PAPER TYPE      WIDTH           HEIGHT         */
  382. /*             LETTER          8.0                 10.6           */
  383. /*                       LEGAL           8.0              13.6           */
  384. /*                 A4              7.787            11.287     */
  385. /*                 B5              6.72              9.713         */
  386.  
  387.  
  388.  
  389.  
  390. /* Paper Sizes (LASER Printer: 300 DPI)                  */
  391. /* Sizes were calculated at base 0 (ergo, there is 1 pixel more)     */
  392. /* All units are in pixels                                               */
  393. /*                     PAPER TYPE      WIDTH           HEIGHT            */
  394. /*                       LETTER        2400             3180             */
  395. /*                       LEGAL         2400             4080             */
  396. /*                       A4            2336             3386             */
  397. /*                       B5            2016             2914             */
  398.  
  399. /* Below are page sizes converted to machine units (MUs)         */
  400. /* 1296 Horizontal MUs == 1 horizontal inch                 */
  401. /* 1152 Vertical MUs == 1 vertical inch                     */
  402.  
  403. int pagemux[] = {            /* A4,B5,Letter,Legal - Horizonta*/
  404.            10092,        /*A4 Portrait         7.787 * 1296  */
  405.            8709,        /*B5 Portrait        6.72  * 1296  */
  406.            10368,        /*Letter Portrait    8.0   * 1296  */
  407.            10368,        /*Legal Portrait     8.0   * 1296  */
  408.  
  409.            14628,        /* A4 Landscape     11.287 * 1296  */
  410.            12588,        /* B5 Landscape      9.713 * 1296  */
  411.            13738,        /* Letter Landscape 10.6   * 1296  */
  412.            17626        /* Legal Landscape  13.6   * 1296  */
  413.             };
  414.  
  415. int pagemuy[] = {            /* A4,B5,Letter,Legal -VERTICAL  */
  416.            13003,        /* A4 Portrait        11.287 * 1152  */
  417.            11189,        /* B5 Portrait         9.713 * 1152  */
  418.            12211,        /* Letter Portrait  10.6   * 1152  */
  419.            15667,        /* Legal Portrait   13.6   * 1152  */ 
  420.  
  421.            8971,        /* A4 Landscape      7.787 * 1152  */
  422.            7741,        /* B5 Landscape      6.72  * 1152  */
  423.            9216,        /* Letter Landscape  8.0   * 1152  */
  424.            9216            /* Legal Landscape   8.0   * 1152  */
  425.         };
  426.  
  427.  
  428. /* mu_array and world_setup must contain the largest x width in mu possible*/
  429. int mu_array[17625];            /* CS store mu to pix conversions */
  430.  
  431.  
  432. int active_prim;            /* flag */
  433. long prim_ptr;                /* ptr to current primitive*/
  434.  
  435. short mlink1[37];
  436.  
  437. PAGE *left_tmplate;
  438. PAGE *right_tmplate;
  439.  
  440. int  temp_page;                /* backup of actual page for template*/
  441.  
  442. PAGE *tpagehd;
  443. PAGE *tcurpage;
  444. ARTICLE *tarthd;
  445. ARTICLE *tcurart;
  446. ARTICLE *ltarthd;
  447. ARTICLE *rtarthd;
  448.  
  449. int  displ_tmpl_flag;            /* display template? 0-no 1 - yes */
  450. int disp_pos;                /* template in front or back?     */
  451. int disp_type;                /* template - both,left,right     */
  452. int kstat;
  453.  
  454. PNUMBER pnum;
  455.  
  456. #define DSMSG 0x1000
  457. int dsbuff[30];
  458. int multi_mode;            /* multiple regions selected         */
  459. int multi_box[4];
  460.  
  461. int rcopy_flag;            /* copy a region flag? */
  462.  
  463. int (*boxes)();
  464.  
  465. long funct_array[10];
  466.  
  467. /**************************************************************************/
  468. /* Function: front_end()                          */
  469. /* Description: Initialize everything else and call event_multi().      */
  470. /**************************************************************************/
  471. front_end(docname)
  472. char *docname;
  473. {
  474.      long msize;
  475.  
  476.      initialize();                   /* Initialize variables    */
  477.      init_structs();                   /* Initialize data structre*/
  478.      world_setup();
  479.      msize = Malloc(-1L);
  480.       
  481.      if(msize >= MIN_MEM_TO_RUN)
  482.      {
  483.     force_preview();
  484.     if(docname)
  485.     {
  486.        load_doc(docname);
  487.     }
  488.         event();                   /* Do the event...         */
  489.      }
  490.      else
  491.     alert_cntre(ALERT14);
  492.      close_work();                   /* and exit program        */
  493. }
  494.  
  495. world_setup()
  496. {
  497.    int dummy;
  498.    register int i;
  499.  
  500.    zrat = 100;
  501.    graf_mouse(2,&dummy);        /* Busy bee */
  502.    for(i = 0;i < 17625;i++)
  503.    {
  504.     mu_array[i] = world_rc_x(i);
  505.    }
  506.    graf_mouse(ARROW,&dummy);
  507. }
  508.  
  509.  
  510. /**************************************************************************/
  511. /*  Function:     initialize()                          */
  512. /*  Description:  Initialize Variables                      */
  513. /**************************************************************************/
  514. initialize()
  515. {
  516.      char *buf;
  517.      int drv;
  518.      char obuf[40];
  519.      register int i;
  520.      int titem;
  521.      int dummy;
  522.  
  523.      location = 0x0L;
  524.      set_ad_dpi();                /* set dialog box for dpi to  */
  525.                         /* at LEAST, 95dpi. Below will*/
  526.                         /* change the defaults, if    */
  527.                         /* necessary...          */
  528.  
  529.      vmicron(mhandle,MICRON,MICRON);        /* adjust memory driver to    */
  530.      vmicron(shandle,MICRON,MICRON);        /* this micron size...      */
  531.  
  532.      xruler_offset = yruler_offset = 0;
  533.      deferhj = 0;
  534.      curr_page  = 1;                    /* Current Page = 1          */
  535.      funcs      = &nada;                /* Default drawing function   */
  536.      mode_flag  = FALSE;            /* solid/text fill - OFF      */
  537.      write_flag = TRUE;                /* write black - default      */
  538.      page_area.g_x = page_area.g_y = 0;     /* Preview area blit defaults */
  539.      page_MFDB.fd_addr = page_ptr;        /* Preview address MFDB       */
  540.      opwidth = opheight = 0;            /* old page width and height  */
  541.    
  542.      vswr_mode(shandle,1);            /* replace mode...            */
  543.      vswr_mode(xor_handle,3);            /* xor mode for xor handle    */
  544.  
  545.      vswr_mode(mhandle,1);            /* replace mode for preview   */
  546.      write_black(mhandle);            /* and set to write black...  */
  547.     
  548.      vswr_mode(rule_handle,3);            /* xor mode for ruler      */
  549.      article_flag = FALSE;
  550.  
  551.      vex_butv(xor_handle,&BUT_OR,&BADDR);
  552.  
  553.      vex_motv(shandle,&NVMOUSE,&OVMOUSE);
  554.      vex_motv(shandle,OVMOUSE,&dummy);
  555.  
  556.  
  557.      if(!restore_defaults())
  558.      {
  559.        set_text_defaults();
  560.        init_tattr();
  561.  
  562.        hpage_size = pagemux[PLETTER - PA4];    /* Default to US LETTER       */
  563.        vpage_size = pagemuy[PLETTER - PA4];
  564.        mutomem(hpage_size,vpage_size,&scan_xres,&scan_yres);
  565.        pagetype   = PLETTER;
  566.        view_size  = PSIZE;               /* Default to Size to Fit     */
  567.        wind_set(prev_handle,WF_INFO,winfo[view_size - PSIZE][unit_type]);
  568.        ruler_flag = FALSE;     
  569.        gl_lstyle = 1;
  570.        gl_lwidth = 0;            /* 0 mu's means line width of 1 pix */
  571.        gl_fstyle = 2;
  572.        gl_fstyle |= 0x8000;        /* high bit set for perimeter on*/
  573.        gl_findex = 10;
  574.        gl_repel = 0;
  575.        gl_repbounds = 0;
  576.        gl_repoffset = 10;
  577.  
  578.        unit_type = 0;                /* Inches    */
  579.        show_grids = 0;
  580.        snap_to_grids = 0;
  581.        disp_pos = 1;            /* Set initial to back      */
  582.        disp_type = 0;            /* Set to Both...        */
  583.        ad_settmpl[SETTBOTH].ob_state = SELECTED;
  584.        ad_settmpl[SETTBACK].ob_state = SELECTED;     
  585.        pnum.pfnum = 1;
  586.        pnum.pptsize = 24*8;    /* ptsize and setsize stored*/
  587.        pnum.pstsize = 24*8;    /* as x8   11-14-88        */
  588.        pnum.units = 0;        /* inches */
  589.        pnum.ljust  = 1;        /* center */
  590.        pnum.rjust  = 1;
  591.        pnum.usage = 2;        /* both   */
  592.        pnum.vpos  = 1;        /* bottom */
  593.        pnum.distance = 0.0;    /* 0 distance */
  594.        pnum.text[0]  = NULLPTR;    /* blank space */
  595.        pnum.display = 0;        /* Don't display till later  */
  596.        pnum.tpage = pnum.fpage = 0; /* number from page 0 to 0 */
  597.  
  598.        hgridspace = 1296;
  599.        vgridspace = 1152;
  600.  
  601.        get_work(prev_handle);
  602.        prev_size = view_size;
  603.        size_fit_handle();
  604.  
  605.      }
  606.      else
  607.      {
  608.        hpage_size = pagemux[pagetype - PA4];
  609.        vpage_size = pagemuy[pagetype - PA4];
  610.        mutomem(hpage_size,vpage_size,&scan_xres,&scan_yres);
  611.  
  612.        get_work(prev_handle);
  613.        prev_size = view_size;
  614.        for(i=PSIZE;i<= PADJCNT;i++)
  615.            menu_icheck(ad_menu,i,FALSE);
  616.        menu_icheck(ad_menu,view_size,TRUE);
  617.        if(pagetype == PLEGAL + 4) /* Landscape Legal Paper?  */
  618.        {              /* Disable 200% and Adjacent pages for now*/
  619.             menu_ienable(ad_menu,PADJCNT,FALSE);
  620.             menu_ienable(ad_menu,P200,FALSE);
  621.        }
  622.       if(!sdevm)
  623.        change_dpi();
  624.     
  625.       if(view_size == PADJCNT)
  626.         recalc_alt_text();
  627.       
  628.       if(view_size != PADJCNT)
  629.      titem = view_size;
  630.       else
  631.         titem = ((curr_page % 2)?(view_size + 1):(view_size));        
  632.  
  633.       wind_set(prev_handle,WF_INFO,winfo[titem - PSIZE][unit_type]);
  634.       wind_set(prev_handle,WF_TOP,&dummy,&dummy,&dummy,&dummy);
  635.       page_area.g_x = page_area.g_y = 0L;
  636.  
  637.       vsf_interior(shandle,0);            /* Set to Solid   */
  638.  
  639.       if( (view_size == PSIZE) ||
  640.       (view_size == PADJCNT))
  641.          pdraw_fit(view_size);
  642.       else
  643.          pdraw_scale();
  644.  
  645.  
  646.       prev_size = view_size;
  647.       zoom_setup();
  648.       cur_scale = get_scale_num(view_size);
  649.       get_work(prev_handle);
  650.       update_preview_blit();
  651.       set_clip(TRUE,&pwork);
  652.       vr_recfl(shandle,pxy);
  653.       clear_window(prev_handle,2,1);
  654.       init_rulers();
  655.       slider_chk();
  656.       set_clip(TRUE,&dpwork);
  657.  
  658.                                 
  659.       menu_text(ad_menu,PRULER,ruler_mode[ruler_flag]); /* ruler   */
  660.  
  661.       for(i=MINCHES;i<=MCICERO;i++)    /* handle unit dialog box  */
  662.         unitobj[i].ob_state = NORMAL;
  663.       unitobj[MINCHES+unit_type].ob_state = SELECTED;
  664.  
  665.     
  666.       if(show_grids)            /* handle display of grids */
  667.        change_icstate(SELECTED,ICBOX7,1);
  668.       else
  669.        change_icstate(NORMAL,ICBOX7,1);
  670.       menu_icheck(ad_menu,OSHOWGR,show_grids);
  671.  
  672.  
  673.       if(snap_to_grids)            /* handle snap to grids       */
  674.        change_icstate(SELECTED,ICBOX8,1);
  675.       else
  676.        change_icstate(NORMAL,ICBOX8,1);
  677.       menu_icheck(ad_menu,OSNAP,snap_to_grids);
  678.       
  679.      }
  680.  
  681.      update_point_dialog();
  682.  
  683.      zdevice = SCANNER;
  684.      SH = vmutopix((int)gltxtattr.lnsp);
  685.  
  686.  
  687.      buf = pathbuf;
  688.      *buf++ = (drv= Dgetdrv()) + 'A';
  689.      *buf++=':';
  690.      *buf++='\\';
  691.      *buf++=0;
  692.      Dgetpath(obuf,drv+1);
  693.      if(strlen(obuf)== 0);
  694.      else strcat(pathbuf,&obuf[1]);
  695.  
  696.      if(pathbuf[strlen(pathbuf)-1]!='\\')
  697.               strcat(pathbuf,"\\");
  698.      icon_setup();
  699.  
  700.  
  701.      gl_region_ptr = gl_grregion_ptr = 0L;
  702.      graph_flag = image_status = 0;
  703. /*     menu_ienable(ad_menu,ACREATE,FALSE);*/
  704.      menu_ienable(ad_menu,RDELETE,FALSE);
  705.      menu_ienable(ad_menu,RUNLINK,FALSE);
  706.      menu_ienable(ad_menu,RCOORD,FALSE);
  707.  
  708.      clipfull = 0;
  709.  
  710.  
  711.      dpath1 = get_edit(ad_paths,PATHTEXT);
  712.      dpath2 = get_edit(ad_paths,PATHCLIP);
  713.      dpath3 = get_edit(ad_paths,PATHGRAP);
  714.      dpath4 = get_edit(ad_paths,PATHDOC);
  715.  
  716.  
  717.      if(read_path(dpath1,dpath2,dpath3,dpath4))
  718.      {
  719.        set_tedit(ad_paths,PATHTEXT,dpath1);
  720.        set_tedit(ad_paths,PATHCLIP,dpath2);
  721.        set_tedit(ad_paths,PATHGRAP,dpath3);
  722.        set_tedit(ad_paths,PATHDOC,dpath4);
  723.      }
  724.      else
  725.      {
  726.        set_tedit(ad_paths,PATHTEXT,pathbuf);
  727.        set_tedit(ad_paths,PATHCLIP,pathbuf);
  728.        set_tedit(ad_paths,PATHGRAP,pathbuf);
  729.        set_tedit(ad_paths,PATHDOC,pathbuf);
  730.        store_paths(dpath1,dpath2,dpath3,dpath4);
  731.      }
  732.      reopen_prim = FALSE;        /* reopen_region init = FALSE*/
  733.      for(i = 0;i < 5;i++)
  734.     mlink1[i] = mlink[i];
  735.      for(i = 21;i < 37;i++)        /* Invert data */
  736.     mlink1[i] = mlink[i] ^ 0xffff;
  737.  
  738.      displ_tmpl_flag = TRUE;
  739.      init_templates();
  740.  
  741.      f_move(&gltxtattr,&pnum.tattrib,sizeof(pnum.tattrib));
  742.      pnum.tattrib.ptsz = pnum.pptsize;
  743.      pnum.tattrib.font = pnum.pfnum;
  744.      pnum.tattrib.ssiz = pnum.pstsize;
  745.      pnum.tattrib.lnsp = (long)pttomu(pnum.pptsize/8);
  746.  
  747.      pnum.tattrib.kernmd = 0;        /* kerning      */
  748.      pnum.tattrib.rvomd  = 0;        /* reverse video*/
  749.  
  750.      if(!sdevm)
  751.         menu_ienable(ad_menu,ODPI,TRUE);
  752.      else
  753.         menu_ienable(ad_menu,ODPI,FALSE);
  754.  
  755.  
  756.      info_what = info_type = 0;  /* set info dialog box to DOC and TEXT  */
  757.      ad_info[info_what + DIDOC].ob_state = SELECTED;
  758.      ad_info[info_type + DITEXT].ob_state = SELECTED;
  759. }
  760.  
  761.  
  762.  
  763. /**************************************************************************/
  764. /*  Function:     event()                          */
  765. /*  Description:  Event Multi Call...                      */
  766. /**************************************************************************/
  767. event()
  768. {
  769. int flag;
  770. int key;
  771.  
  772.     done = FALSE;
  773.     while(done == FALSE)
  774.     {
  775.        flag = MU_BUTTON|MU_MESAG|MU_KEYBD;
  776.        if(ruler_flag)
  777.        flag |= MU_M1;
  778.        evnt_which = evnt_multi(flag,
  779.                  1,1,1,
  780.                  1,oldx,oldy,1,1,
  781.                  0,0,0,0,0,
  782.                  msg_buff,
  783.                  0,0,
  784.                  &newx,&newy,
  785.                  &dummy,
  786.                  &kstat,    /* Kbd shift state for GOG      */
  787.                  &key,
  788.                  &dummy);
  789.  
  790.        wind_update(TRUE);
  791.        if(evnt_which & MU_M1)
  792.        {
  793.        do_rule_mark();
  794.            oldx = newx;
  795.            oldy = newy;
  796.        }
  797.        if(evnt_which & MU_KEYBD)
  798.           hndl_keybd(key);
  799.  
  800.        if(evnt_which & MU_MESAG)
  801.        if(msg_buff[0] == 0x1000)
  802.         hndl_acc();
  803.        else
  804.                 mesag_handle(msg_buff);
  805.  
  806.        if(evnt_which & MU_BUTTON)
  807.                    button_handler(newx,newy);
  808.  
  809.        if(check_TWtop()) Editor();
  810.        wind_update(FALSE);
  811.     }
  812. }
  813.  
  814.  
  815. hndl_acc()
  816. {
  817.    long *buffptr;
  818.    int id;
  819.    long holder;
  820.  
  821.    id = appl_find("DSACC   ");
  822.    if(id != -1)
  823.    {
  824.       msg_buff[0] = DSMSG;
  825.       buffptr = (long *)(msg_buff + 1);
  826.       *buffptr = dsbuff;
  827.       holder = &pagehd;
  828.       f_move(&holder,&dsbuff[0],4);
  829.       holder = &arthd;
  830.       f_move(&holder,&dsbuff[2],4);
  831.       holder = &gl_region_ptr;
  832.       f_move(&holder,&dsbuff[4],4);
  833.       holder = &gl_grregion_ptr;
  834.       f_move(&holder,&dsbuff[6],4);
  835.       holder = &curprim;
  836.       f_move(&holder,&dsbuff[8],4);
  837.       dsbuff[10] = active_prim;            /* Primitive selected? */
  838.       dsbuff[11] = curr_page;            /* Current page           */
  839.       holder = &cp;
  840.       f_move(&holder,&dsbuff[12],4);
  841.       holder = funct_array;
  842.       f_move(&holder,&dsbuff[14],4);
  843.       dsbuff[16] = multi_mode;
  844.       dsbuff[17] = hpage_size;
  845.       dsbuff[18] = vpage_size;
  846.       funct_array[0] = &lmalloc;
  847.       funct_array[1] = &free;
  848.       funct_array[2] = &force_preview;
  849.       funct_array[3] = &do_blit;
  850.       funct_array[4] = &dotext;
  851.       funct_array[5] = &redraw_laser;
  852.       funct_array[6] = &scrntomu;
  853.       funct_array[7] = &recalc_txtptrs;
  854.       appl_write(id,16,msg_buff);
  855.    }
  856. }
  857.  
  858. /**************************************************************************/
  859. /* Function: hndl_keybd()                          */
  860. /* Description: Keyboard handler                      */
  861. /**************************************************************************/
  862. hndl_keybd(key)
  863. int key;
  864. {
  865.     register int menu;
  866.     register int item;
  867.     char ch;
  868.     ch = (char)key & 0xff;
  869.     switch(ch)
  870.     {
  871.   /* FILE MENU ITEMS    */
  872.     case 0x0e:
  873.         menu = TFILE;                /* ^N */
  874.         item = FNEW;
  875.         break;
  876.     case 0x0c:
  877.         menu = TFILE;                /* ^L */
  878.         item = FLOADDOC;
  879.         break;
  880.     case 0x13:
  881.         menu = TFILE;            /* ^S */
  882.         item = FSAVEDOC;
  883.         break;
  884.     case 0x1b:    
  885.         menu = TFILE;            /* ^[ */
  886.         item = FLOADCLI;
  887.         break;
  888.     case 0x1d:    
  889.         menu = TFILE;            /* ^] */
  890.         item = FSAVECLI;
  891.         break;
  892.     case 0x10:    
  893.         menu = TFILE;            /* ^P */
  894.         item = FPRINT;
  895.         break;
  896.     case 0x11:    
  897.         menu = TFILE;            /* ^Q */
  898.         item = FQUIT;
  899.         break;
  900.   /* PAGE MENU ITEMS    */
  901.     case 0x07:    
  902.         menu = TPAGE;            /* ^G */
  903.         item = PGOTO;
  904.         break;
  905.     case 0x00:
  906.         menu = TPAGE;
  907.         if(key == 0x4d00)
  908.             item = PNEXT;
  909.         else if(key == 0x4b00)
  910.             item = PPREV;
  911.         else 
  912.             item = 0;
  913.         break;
  914.     case 0x16:    
  915.         menu = TPAGE;            /* ^V */
  916.         item = PCLTOP;
  917.         break;
  918.     case 0x18:    
  919.         menu = TPAGE;            /* ^X */
  920.         item = PPTOCL;
  921.         break;
  922.     case 0x0b:    
  923.         menu = TPAGE;            /* ^K */
  924.         item = PDELCLIP;
  925.         break;
  926.   /* REGION MENU ITEMS  */
  927.     case 0x14:    
  928.         menu = TREGION;            /* ^T */
  929.         item = RTOGGLE;
  930.         break;
  931.     case 0x09:    
  932.         menu = TREGION;            /* ^I */
  933.         item = RDIMAGES;
  934.         break;
  935.     case 0x01:    
  936.         menu = TREGION;            /* ^A */
  937.         item = RGRATTR;
  938.         break;
  939.  
  940.     case 0x1C:
  941.         menu = TREGION;            /* ^\ */
  942.         item = RSCANOFF;
  943.         break;
  944.  
  945.   /* SETUP MENU ITEMS   */
  946.     case 0x06:    
  947.         menu = TSETUP;            /* ^F */
  948.         item = PPOINT;
  949.         break;
  950.     case 0x03:    
  951.         menu = TSETUP;            /* ^C */
  952.         item = CHARCPMN;
  953.         break;
  954.     case 0x08:    
  955.         menu = TSETUP;            /* ^H */
  956.         item = HYPARMN;
  957.         break;
  958.     case 0x0a:    
  959.         menu = TSETUP;            /* ^J */
  960.         item = JUSTMN;
  961.         break;
  962.     case 0x17:    
  963.         menu = TSETUP;            /* ^W */
  964.         item = WSPMN;
  965.         break;
  966.   /* OPTIONS MENU ITEMS */
  967.     case 0x12:    
  968.         menu = TOPTIONS;        /* ^R */
  969.         item = PRULER;
  970.         break;
  971.     case 0x15:
  972.         menu = TOPTIONS;
  973.         item = PUNITS;            /* ^U */
  974.         break;
  975.     case 0x0d:
  976.         menu = TOPTIONS;
  977.         item = OGRIDSP;            /* ^M */
  978.         break;
  979.     case 0x1a:        
  980.         menu = TOPTIONS;        /* ^Z */
  981.         item = OSHOWGR;
  982.         break;
  983.     case 0x0f:        
  984.         menu = TOPTIONS;        /* ^O */
  985.         item = OSNAP;
  986.         break;
  987.     default:
  988.         item = 0;
  989.         break;
  990.     }
  991.     if(item && !(ad_menu[item].ob_state & DISABLED))
  992.     {
  993.     if(!(ad_menu[menu].ob_state & DISABLED))
  994.         menu_handler(1,item);
  995.     }
  996. }
  997.  
  998.  
  999.  
  1000. /**************************************************************************/
  1001. /* Function:    Mesag_handler()                          */
  1002. /* Description: Event Message Handler                      */
  1003. /**************************************************************************/
  1004. mesag_handle(msg_buff)
  1005. register int msg_buff[];
  1006. {
  1007.     switch(msg_buff[0])
  1008.     {
  1009.       case MN_SELECTED: menu_handler(msg_buff[3],msg_buff[4]);
  1010.             break;
  1011.  
  1012.       case WM_REDRAW:   do_redraw(msg_buff);
  1013.             break;
  1014.  
  1015.       case WM_TOPPED:    top_window(msg_buff[3],0L);
  1016.             do_redraw(msg_buff);
  1017.             break;
  1018.  
  1019.       case WM_CLOSED:   close_window(msg_buff[3]);
  1020.             break;
  1021.  
  1022.       case WM_FULLED:   full_window(msg_buff[3]);
  1023.             break;
  1024.  
  1025.       case WM_ARROWED:  arrow_window(msg_buff[3],msg_buff[4]);
  1026.             break;
  1027.  
  1028.       case WM_HSLID:    hslide_window(msg_buff[3],msg_buff[4]);
  1029.             break;
  1030.  
  1031.       case WM_VSLID:    vslide_window(msg_buff[3],msg_buff[4]);
  1032.             break;
  1033.  
  1034.       case WM_SIZED:    size_window(msg_buff);
  1035.             break;
  1036.  
  1037.       case WM_MOVED:    move_window(msg_buff);
  1038.             break;
  1039.     }
  1040. }
  1041.  
  1042.  
  1043. /**************************************************************************/
  1044. /* Function:    menu_handler()                          */
  1045. /* Description: Menu Control Routines                      */
  1046. /**************************************************************************/
  1047. menu_handler(menu,item)
  1048. int menu;
  1049. int item;
  1050. {
  1051.         int x,y;
  1052.     int rtmplate_flag;
  1053.         
  1054.     menu_tnormal(ad_menu,menu,1);
  1055.     switch(item)
  1056.     {
  1057.       case ABOUT:    do_about();
  1058.             active_prim = FALSE;
  1059.             ad_deskset[OK].ob_state = NORMAL;
  1060.             break;
  1061.  
  1062.       case FNEW:    
  1063.             if(alert_cntre(ALERT4) == 1)
  1064.             {
  1065.                  graf_mouse(BUSY_BEE,&dummy);
  1066.              /*    menu_ienable(ad_menu,ACREATE,FALSE);*/
  1067.                  menu_ienable(ad_menu,ODELPRIM,FALSE);
  1068.                  menu_ienable(ad_menu,OPCOORD,FALSE);
  1069.                  menu_ienable(ad_menu,OMOVEFNT,FALSE);
  1070.                  menu_ienable(ad_menu,OMOVEBAK,FALSE);
  1071.                  if(view_size == PADJCNT)
  1072.                                 wind_set(prev_handle,WF_INFO,
  1073.                       winfo[PADJCNT - PSIZE + 1][unit_type]);
  1074.                  article_flag = FALSE;
  1075.                              erase_all(1);
  1076.                  init_tattr();
  1077.                  strcpy(pfname," Preview Window ");
  1078.                  wind_set(prev_handle,WF_NAME,pfname,0,0);
  1079.                      graf_mouse(ARROW,&dummy);        
  1080.             }
  1081.             break;
  1082.  
  1083.       case FLOADDOC: 
  1084.                 graf_mouse(BUSY_BEE,&dummy);
  1085.             active_prim = FALSE;
  1086.             load_doc(0L);
  1087.             if(deferhj)
  1088.             {
  1089.                menu_icheck(ad_menu,ADEFER,0);
  1090.                deferhj = 0;
  1091.             }
  1092.                 graf_mouse(ARROW,&dummy);        
  1093.             break;
  1094.  
  1095.       case FSAVEDOC:
  1096.                 graf_mouse(BUSY_BEE,&dummy);
  1097.                 if(deferhj)
  1098.                 {
  1099.                menu_icheck(ad_menu,ADEFER,0);
  1100.                deferhj = 0;
  1101.                recalc_txtptrs();
  1102.                 }
  1103.             active_prim = FALSE;
  1104.             save_doc();
  1105.                 graf_mouse(ARROW,&dummy);        
  1106.             break;
  1107.  
  1108.       case FDINFO:  do_info();
  1109.             break;
  1110.  
  1111.       case FPRINT:     active_prim = FALSE;
  1112.             change_icstate(SELECTED,ICBOX6,1);
  1113.             output_doc();
  1114.             change_icstate(NORMAL,ICBOX6,1);
  1115.             break;
  1116.  
  1117.       case FQUIT:   if(form_alert(2,quiter) == 1)
  1118.             {
  1119.                    graf_mouse(BUSY_BEE,&dummy);
  1120.                   done = TRUE;
  1121.                       delete_clip();
  1122.               erase_all(0);
  1123.                   graf_mouse(ARROW,&dummy);        
  1124.             }
  1125.             break;
  1126.  
  1127.       case FLOADCLI:active_prim = FALSE; 
  1128.                 graf_mouse(BUSY_BEE,&dummy);
  1129.             if(!load_clipb())
  1130.             {
  1131.                clipfull = 1;
  1132.                icnptr->ib_pdata = &clipf[0];
  1133.                form_dial(3,0,0,0,0,
  1134.                 ad_bkgrnd[CLIPOBJ].ob_x,
  1135.                 ybook,
  1136.                 ad_bkgrnd[CLIPOBJ].ob_width,
  1137.                 syres - ybook);
  1138.                        menu_ienable(ad_menu,ACREATE,1);
  1139.             }
  1140.                 graf_mouse(ARROW,&dummy);        
  1141.             break;
  1142.  
  1143.       case FSAVECLI:
  1144.                  graf_mouse(BUSY_BEE,&dummy);
  1145.              save_clipb();
  1146.                  graf_mouse(ARROW,&dummy);        
  1147.              break;
  1148.  
  1149.           case FLOADTMP: graf_mouse(BUSY_BEE,&dummy);
  1150.              active_prim = FALSE;
  1151.              load_tmplate();
  1152.                    graf_mouse(ARROW,&dummy);        
  1153.              break;
  1154.     
  1155.           case FSAVETMP: graf_mouse(BUSY_BEE,&dummy);
  1156.              active_prim = FALSE;
  1157.              save_tmplate();
  1158.                   graf_mouse(ARROW,&dummy);        
  1159.              break;
  1160.  
  1161.       case FLOADTAG: graf_mouse(BUSY_BEE,&dummy);
  1162.              active_prim = FALSE;
  1163.              load_tags();
  1164.                  graf_mouse(ARROW,&dummy);        
  1165.              break;
  1166.  
  1167.       case FSAVETAG: graf_mouse(BUSY_BEE,&dummy);
  1168.              active_prim = FALSE;
  1169.              save_tags();
  1170.                  graf_mouse(ARROW,&dummy);        
  1171.              break;
  1172.  
  1173.       case PSIZE:
  1174.       case P50:
  1175.       case P75:
  1176.       case PACTUAL:
  1177.       case P200:
  1178.       case PADJCNT: do_view_size(item);
  1179.             break;
  1180.  
  1181.       case RGRATTR: do_grdialog();
  1182.             active_prim = FALSE;
  1183.             break;
  1184.  
  1185.           case RSCANOFF: 
  1186.             do_scoffset();
  1187.             active_prim = FALSE;
  1188.             break;
  1189.  
  1190.       case RCOORD: 
  1191.             do_rcoord();
  1192.             break;
  1193.  
  1194.       case PGOTO:   do_go_page();
  1195.             active_prim = FALSE;
  1196.             break;
  1197.  
  1198.       case PPREV:
  1199.       case PNEXT:   do_flip_page(item);
  1200.                 do_pagenum(curr_page,(curr_page%2)?1:0);
  1201.             active_prim = FALSE;
  1202.             break;
  1203.  
  1204.       case PDELETE: do_delpage();
  1205.             active_prim = FALSE;
  1206.             break;
  1207.  
  1208.       case PINSERT:    active_prim = FALSE;
  1209.             ins_page();
  1210.             force_draw_flag = TRUE;
  1211.             recalc_txtptrs();
  1212.             force_preview();
  1213.             break;
  1214.  
  1215.       case PRULER:  ruler_flag ^= TRUE;
  1216.             menu_text(ad_menu,PRULER,ruler_mode[ruler_flag]);
  1217.                 wind_set(prev_handle,WF_TOP,&dummy,&dummy,&dummy,&dummy);
  1218.             get_work(prev_handle);
  1219.             update_preview_blit();
  1220.             gsx_moff();
  1221.             if((view_size == PSIZE) ||
  1222.                (view_size == PADJCNT))
  1223.             {
  1224.                force_draw_flag = TRUE;
  1225.                vsf_interior(shandle,0);
  1226.                pdraw_fit(view_size);
  1227.                vr_recfl(shandle,pxy);
  1228.                zoom_setup();
  1229.                cur_scale = get_scale_num(view_size);
  1230.                get_work(prev_handle);
  1231.                update_preview_blit();
  1232.                set_clip(TRUE,&pwork);
  1233.             }
  1234.             clear_window(prev_handle,2,1);
  1235.             slider_chk();
  1236.             set_clip(TRUE,&dpwork);
  1237.             
  1238.             if(!ruler_flag)
  1239.                 xruler_offset = yruler_offset = 0;
  1240.             else
  1241.                        init_rulers();
  1242.             send_redraw(prev_handle);
  1243.             gsx_mon();
  1244.             break;
  1245.  
  1246.       case PUNITS:  if(do_unit_dialog())
  1247.             {
  1248.               if(ruler_flag)
  1249.               {
  1250.                  init_rulers();
  1251.                   if(show_grids)
  1252.                         force_preview();
  1253.                  else
  1254.                         send_redraw(prev_handle);
  1255.               }
  1256.             }
  1257.              break;
  1258.  
  1259.       case PCLTOP:  
  1260.             if(clipfull)
  1261.             {
  1262.                active_prim = FALSE;
  1263.                do_clip_dialog();
  1264.             }
  1265.                         break;
  1266.  
  1267.       case PPTOCL:  
  1268.             if(!clipfull)
  1269.             {
  1270.                    if(page_to_clip())
  1271.                {
  1272.                   clipfull = 1;
  1273.                   icnptr->ib_pdata = &clipf[0];
  1274.                   form_dial(3,0,0,0,0,
  1275.                        ad_bkgrnd[CLIPOBJ].ob_x,
  1276.                        ybook,
  1277.                        ad_bkgrnd[CLIPOBJ].ob_width,
  1278.                        syres - ybook);
  1279.                }
  1280.             }
  1281.             else
  1282.                alert_cntre(ALERT26);       
  1283.             break;
  1284.  
  1285.  
  1286.       case PDELCLIP:
  1287.             if(clipfull)
  1288.             {
  1289.                clipfull = 0;
  1290.                delete_clip();
  1291.                icnptr->ib_pdata = clipe;
  1292.                form_dial(3,0,0,0,0,
  1293.                        ad_bkgrnd[CLIPOBJ].ob_x,
  1294.                        ybook,
  1295.                        ad_bkgrnd[CLIPOBJ].ob_width,
  1296.                        syres - ybook);
  1297.             }
  1298.             break;
  1299.  
  1300.       case PPAGENUM: page_numbering();
  1301.              active_prim = FALSE;
  1302.              break;
  1303.  
  1304.           case ACREATE: make_article();
  1305.             active_prim = FALSE;
  1306.             break;
  1307.  
  1308.       case ACLOSE:  close_article();
  1309.             break;
  1310.  
  1311.       case AAUTOFL: do_autoflow();
  1312.             active_prim = FALSE;
  1313.             break;
  1314.  
  1315.       case ASAVEART: do_saveart();
  1316.              active_prim = FALSE;
  1317.              break;
  1318.  
  1319.       case ASELECT:    active_prim = FALSE;
  1320.             do_artopen();
  1321.             break;
  1322.  
  1323.       case ADELETE: do_artdelete();
  1324.             active_prim = FALSE;
  1325.             break;
  1326.  
  1327.       case ADEFER:  deferhj ^= 1;
  1328.             menu_icheck(ad_menu,ADEFER,deferhj);
  1329.             if(!deferhj)
  1330.                recalc_txtptrs();
  1331.             break;
  1332.  
  1333.       case RCREATE: rmenu_fix(1);
  1334.             active_prim = FALSE;
  1335.             genesis_region();
  1336.             
  1337.             if(bgicptr->bi_pdata == icdata)
  1338.             {
  1339.                bgicptr->bi_pdata = primicons;
  1340.                objc_offset(ad_bkgrnd,BGICBOX,&x,&y);
  1341.                ad_bkgrnd[ICBOX6].ob_state = DISABLED;
  1342.                ad_bkgrnd[ICBOX7].ob_state = DISABLED;
  1343.                ad_bkgrnd[ICBOX8].ob_state = DISABLED;
  1344.                clr_bgicons(0);
  1345.                form_dial(3,0,0,0,0,x,y,
  1346.                 ad_bkgrnd[BGICBOX].ob_width,
  1347.                 ad_bkgrnd[BGICBOX].ob_height);
  1348.             }
  1349.             clr_bgicons(1);
  1350.             change_icstate(SELECTED,(OBOX - OPOLYGON)+ICBOX2,1);
  1351.             break;
  1352.  
  1353.       case RDELETE: 
  1354.             if(alert_cntre(ALERT7) == 1)
  1355.                         {
  1356.               do_delregion();
  1357.               active_prim = FALSE;
  1358.               }
  1359.             clear_regprim_flags();
  1360.             break;
  1361.  
  1362.       case RUNLINK: do_unlinkreg();
  1363.             break;
  1364.  
  1365.           case ROPENGR: rmenu_fix(1);
  1366.             graphic_region();
  1367.             if(bgicptr->bi_pdata == icdata)
  1368.             {
  1369.                bgicptr->bi_pdata = primicons;
  1370.                objc_offset(ad_bkgrnd,BGICBOX,&x,&y);
  1371.                clr_bgicons(0);
  1372.                form_dial(3,0,0,0,0,x,y,
  1373.                 ad_bkgrnd[BGICBOX].ob_width,
  1374.                 ad_bkgrnd[BGICBOX].ob_height);
  1375.             }
  1376.             clr_bgicons(1);
  1377.             change_icstate(SELECTED,(OBOX - OPOLYGON)+ICBOX2,1);
  1378.             break;
  1379.  
  1380.       case RCLOSE:  close_region();
  1381.             break;
  1382.  
  1383.           case RTOGGLE: 
  1384.             graf_mouse(BUSY_BEE,&dummy);
  1385.             if(mode_flag)
  1386.                change_icstate(NORMAL,ICBOX3,1);
  1387.             else
  1388.                change_icstate(SELECTED,ICBOX3,1);
  1389.             clear_regprim_flags();
  1390.             display_toggle();
  1391.                     graf_mouse(ARROW,&dummy);        
  1392.             break;
  1393.  
  1394.           case RDIMAGES: image_status ^= TRUE;
  1395.              graf_mouse(BUSY_BEE,&dummy);
  1396.              if(image_status)
  1397.                 change_icstate(SELECTED,ICBOX4,1);
  1398.              else
  1399.                 change_icstate(NORMAL,ICBOX4,1);
  1400.              menu_icheck(ad_menu,RDIMAGES,image_status);
  1401.              force_draw_flag = TRUE;
  1402.              clear_regprim_flags();
  1403.              force_preview();
  1404.                  graf_mouse(ARROW,&dummy);        
  1405.              break;
  1406.  
  1407.           case RWRITE:  write_flag ^= TRUE;
  1408.             menu_text(ad_menu,RWRITE,write_mode[write_flag]);
  1409.             break;
  1410.  
  1411.       case RMOVEFNT:  graf_mouse(BUSY_BEE,&dummy);
  1412.               region_front();
  1413.                    graf_mouse(ARROW,&dummy);        
  1414.               break;
  1415.  
  1416.       case RMOVEBAK:  graf_mouse(BUSY_BEE,&dummy);
  1417.               region_back();
  1418.                   graf_mouse(ARROW,&dummy);        
  1419.               break;
  1420.  
  1421.  
  1422.       case OPOLYGON:
  1423.       case OCIRCLE:
  1424.       case OELLIPSE:
  1425.       case OBOX:
  1426.       case OLINE:
  1427.       case ORBOX:
  1428.       case OIMAGE:  
  1429.             clr_bgicons(1);
  1430.             change_icstate(SELECTED,(item - OPOLYGON)+ICBOX2,1);
  1431.             draw_items(item);
  1432.             break;
  1433.     
  1434.           case OADDPRIM:
  1435.              if(region_ptr)
  1436.              {
  1437.                rmenu_fix(1);
  1438.                reopen_region();
  1439.                if(bgicptr->bi_pdata == icdata)
  1440.                {
  1441.                  bgicptr->bi_pdata = primicons;
  1442.                  if(mode_flag)    /* Enable close box */
  1443.                     ad_bkgrnd[ICBOX1].ob_state = NORMAL;
  1444.                  if(gl_region_ptr)    /* Text region */
  1445.                  {
  1446.                     ad_bkgrnd[ICBOX6].ob_state = DISABLED;
  1447.                     ad_bkgrnd[ICBOX7].ob_state = DISABLED;
  1448.                     ad_bkgrnd[ICBOX8].ob_state = DISABLED;
  1449.                  }
  1450.                  clr_bgicons(0);
  1451.                  objc_offset(ad_bkgrnd,BGICBOX,&x,&y);
  1452.                  form_dial(3,0,0,0,0,x,y,
  1453.                  ad_bkgrnd[BGICBOX].ob_width,
  1454.                  ad_bkgrnd[BGICBOX].ob_height);
  1455.                }
  1456.                clr_bgicons(1);
  1457.                change_icstate(SELECTED,(OBOX - OPOLYGON)+ICBOX2,1);
  1458.              }
  1459.              else
  1460.                 clear_regprim_flags();
  1461.              break;
  1462.  
  1463.       case ODELPRIM: del_prim();
  1464.              break;
  1465.  
  1466.           case OPCOORD:  do_pcoord();
  1467.              break;
  1468.   
  1469.           case OMOVEFNT: graf_mouse(BUSY_BEE,&dummy);
  1470.              prim_front();
  1471.                  graf_mouse(ARROW,&dummy);        
  1472.              break;
  1473.  
  1474.       case OMOVEBAK: graf_mouse(BUSY_BEE,&dummy);
  1475.              prim_back();
  1476.                  graf_mouse(ARROW,&dummy);        
  1477.              break;
  1478.  
  1479.  
  1480.     /* Options */
  1481.       case OSHOWGR: show_grids ^= 1;
  1482.             if(show_grids)
  1483.                change_icstate(SELECTED,ICBOX7,1);
  1484.             else
  1485.                change_icstate(NORMAL,ICBOX7,1);
  1486.             menu_icheck(ad_menu,OSHOWGR,show_grids);
  1487.             force_preview();
  1488.             break;
  1489.  
  1490.       case OGRIDSP: if(do_grid_space())
  1491.             {
  1492.               if(show_grids)
  1493.                   force_preview();
  1494.             }
  1495.             break;
  1496.       case OSNAP:    snap_to_grids ^= 1;
  1497.             if(snap_to_grids)
  1498.                change_icstate(SELECTED,ICBOX8,1);
  1499.             else
  1500.                change_icstate(NORMAL,ICBOX8,1);
  1501.             menu_icheck(ad_menu,OSNAP,snap_to_grids);
  1502.             break;        
  1503.  
  1504.        case OEDITTMP: do_template_edit(); 
  1505.              active_prim = FALSE;
  1506.                break;
  1507.  
  1508.           case OERASETP: erase_template();    /* erase current template */
  1509.              active_prim = FALSE;
  1510.              break;
  1511.  
  1512.           case ODISPTMP: displ_tmpl_flag ^= TRUE;
  1513.              menu_text(ad_menu,ODISPTMP,disp_tmpl[displ_tmpl_flag]);
  1514.              force_preview();
  1515.              break;          
  1516.  
  1517.           case OTMPLOPT: set_template();
  1518.              break;
  1519.  
  1520.       case ODELTMPL: if(alert_cntre(ALERT28) == 1)
  1521.              {
  1522.               rtmplate_flag = tmplate_flag;
  1523.               active_prim = FALSE;
  1524.               delete_tmplates();
  1525.               if(tmplate_flag)
  1526.               {
  1527.                        curpage=((curr_page%2)?(right_tmplate):(left_tmplate));
  1528.                pagehd = curpage;
  1529.                curr_page = pagehd->pagenum;
  1530.                curart = arthd = ((curr_page%2)?(rtarthd):(ltarthd));
  1531.                    wind_set(prev_handle,WF_NAME,basefname,0,0);
  1532.               }
  1533.               tmplate_flag = rtmplate_flag;
  1534.               force_preview();
  1535.              }
  1536.              break;
  1537.  
  1538.       case ODPI:    do_dpi();
  1539.             active_prim = FALSE;
  1540.             break;
  1541.           
  1542.           case OCACHE:  IF_close();
  1543.             IF_open(0);        /* Free cache memory */
  1544.             break;
  1545.  
  1546.     /* setup */                
  1547.     
  1548.       case DPTDRS:    Fnt_cmd('D',"");
  1549.             active_prim = FALSE;
  1550.             break;
  1551.  
  1552.       case MDTDRS:
  1553.             Fnt_cmd('M',fntdrs);
  1554.             active_prim = FALSE;
  1555.             break;
  1556.  
  1557.       case DICTMN:
  1558.             runExDict();    
  1559.               break;
  1560.  
  1561.          case TRANMN:  runTrans();
  1562.             break;
  1563.  
  1564.       case HYLANMN:
  1565.             do_hylang();
  1566.               break;
  1567.  
  1568.       case PWUPFLMN:
  1569.             do_pwrup();
  1570.               break;
  1571. /*      case FONTSMN:*/
  1572.       case PPOINT:
  1573.             /*do_fonts();*/        /* GOG   version */
  1574.             do_point_size();    /* ATARI version */
  1575.             active_prim = FALSE;
  1576.               break;
  1577.  
  1578.       case CHARCPMN:
  1579.             do_chcomp();
  1580.             active_prim = FALSE;
  1581.               break;
  1582.       case WSPMN:
  1583.             do_wdsp();
  1584.             active_prim = FALSE;
  1585.               break;
  1586.  
  1587.       case HYPARMN:
  1588.             do_hypar();
  1589.               break;
  1590.       case JUSTMN:
  1591.             do_just();
  1592.               break;
  1593.         case SPDEF:    
  1594.             do_page_def();
  1595.             break;
  1596.  
  1597.       case SPATHS:  do_set_paths();
  1598.             break;
  1599.  
  1600.       case SDEFPARM: save_parameters();
  1601.              break;
  1602.         }
  1603. }
  1604.  
  1605.  
  1606. rmenu_fix(disable)
  1607. int disable;
  1608. {
  1609.    register int i;
  1610.  
  1611.    for(i = TFILE;i <= TOPTIONS;i++)
  1612.         menu_ienable(ad_menu,0x8000|i,disable^1);
  1613.    menu_ienable(ad_menu,0x8000|TREGION,1);
  1614.    menu_ienable(ad_menu,0x8000|TOBJECTS,1);
  1615.    if(disable)
  1616.    {
  1617.           for(i = RUNLINK;i <= RMOVEBAK;i++)
  1618.        menu_ienable(ad_menu,i,0);
  1619.     for(i = OADDPRIM;i <= OMOVEBAK;i++)
  1620.        menu_ienable(ad_menu,i,0);
  1621.     menu_ienable(ad_menu,RWRITE,TRUE);    /* still need RWRITE */
  1622.    }
  1623.    else
  1624.    {
  1625.     menu_ienable(ad_menu,0x8000|TEXT,0);
  1626.     menu_ienable(ad_menu,RTOGGLE,1);
  1627.     menu_ienable(ad_menu,RDIMAGES,1);
  1628.     menu_ienable(ad_menu,RWRITE,1);
  1629.     menu_ienable(ad_menu,RGRATTR,1);
  1630.     menu_ienable(ad_menu,RSCANOFF,1);
  1631.    }
  1632. }
  1633.  
  1634.  
  1635. amenu_fix(disable)
  1636. int disable;
  1637. {
  1638.    register int i;
  1639.  
  1640.    for(i = TFILE;i <= TOPTIONS;i++)
  1641.     menu_ienable(ad_menu,0x8000|i,disable^1);
  1642.    menu_ienable(ad_menu,0x8000|TPAGE,1);
  1643.    menu_ienable(ad_menu,0x8000|TARTICLE,1);
  1644.    menu_ienable(ad_menu,0x8000|TEXT,0);
  1645.    for(i = PSIZE;i <= PINSERT;i++)
  1646.     menu_ienable(ad_menu,i,disable^1);
  1647.    menu_ienable(ad_menu,ASELECT,disable^1);
  1648.    menu_ienable(ad_menu,ADELETE,disable^1);
  1649.    menu_ienable(ad_menu,ADEFER,disable^1);
  1650.    if(disable)
  1651.    {
  1652.     menu_ienable(ad_menu,PGOTO,1);
  1653.     menu_ienable(ad_menu,PPREV,1);
  1654.     menu_ienable(ad_menu,PNEXT,1);
  1655.    }
  1656.    else
  1657.    {
  1658.     menu_ienable(ad_menu,PADJCNT+1,0);    /* disable dashed separator*/
  1659.     menu_ienable(ad_menu,PINSERT+1,0);
  1660.    }
  1661. }
  1662.     
  1663.  
  1664. /**************************************************************************/
  1665. /* Function:    button_handler()                      */
  1666. /* Description: Mouse Button Control Routines                  */
  1667. /**************************************************************************/
  1668. button_handler(mx,my)
  1669. int mx;
  1670. int my;
  1671. {
  1672.    int whandle;
  1673.    int obj;
  1674.    int axy[4];
  1675.    int planted;
  1676.    int tmp_buff[8];
  1677.    int event;
  1678.    int omx,omy;
  1679.  
  1680.    whandle = wind_find(mx,my);
  1681.    if(!whandle)
  1682.    {
  1683.      obj = objc_find(ad_bkgrnd,BGICBOX,MAX_DEPTH,mx,my);
  1684.      if(obj != -1)
  1685.      {
  1686.         hndl_icons(obj);   
  1687.       return;
  1688.      }
  1689.    }
  1690.  
  1691.    screen_clip();                /* set screen clipping    */
  1692.  
  1693.    if(article_flag)                /* if opening a new       */
  1694.    {                        /* let's calculate links  */
  1695.       if(whandle == prev_handle)
  1696.       {
  1697.          do_hot_link(mx,my);
  1698.          return;
  1699.       }
  1700.    }
  1701.  
  1702.  
  1703.    if(funcs == &nada)                /* no primitive to draw   */
  1704.    {                        /* so we select a region  */
  1705.       if(BSTATE == 1)
  1706.               do_nada(mx,my);
  1707.       
  1708.       if(BSTATE == 2)
  1709.         do_edit_prim();
  1710.       return;
  1711.    }
  1712.  
  1713.  
  1714.  
  1715.  
  1716.     
  1717.    if((whandle != prev_handle) || !check_dpwork_box(mx,my))
  1718.                 return; /*Didn't click within work area */
  1719.  
  1720.    if(snap_to_grids)
  1721.     snap_to_grid(&mx,&my);
  1722.    pxy[0] = pxy[2] = newx = mx;
  1723.    pxy[1] = pxy[3] = newy = my;
  1724.  
  1725.    wind_update(BEG_MCTRL);
  1726.    wind_update(BEG_UPDATE);
  1727.  
  1728.    gsx_moff();
  1729.  
  1730.    if(gl_grregion_ptr)
  1731.         get_grattr(gl_grregion_ptr,glgrattr);
  1732.  
  1733.    scrn2clip();
  1734.  
  1735.    if(funcs == &poly_draw)           /* polygon drawing routine*/
  1736.    {
  1737.        if(BSTATE == 1)
  1738.              poly_handler(mx,my);
  1739.        else
  1740.        {
  1741.           gsx_mon();
  1742.           wind_update(END_UPDATE);
  1743.           wind_update(END_MCTRL);
  1744.        }   
  1745.        mclip();
  1746.        return;
  1747.    }
  1748.  
  1749.  
  1750.    button = 1;
  1751.    evnt_mouse(1,mx,my,1,1,&oldx,&oldy,&button,&key);
  1752.    if(button == 0)
  1753.    {
  1754.      gsx_mon();
  1755.      wind_update(END_UPDATE);
  1756.      wind_update(END_MCTRL);
  1757.      mclip();
  1758.      return;
  1759.    }
  1760.    
  1761.  
  1762.    while(button == 1)
  1763.    {
  1764.       graf_mkstate(&newx,&newy,&button,&key);
  1765.       if( (oldx != newx) || (oldy != newy))
  1766.       {
  1767.      do_rule_mark();
  1768.          (*funcs)(xor_handle);
  1769.          pxy[2] = newx;
  1770.          pxy[3] = newy;
  1771.          (*funcs)(xor_handle);
  1772.       }
  1773.       oldx = newx;
  1774.       oldy = newy;
  1775.    }
  1776.  
  1777.    planted = TRUE;
  1778.    axy[0] = pxy[0];
  1779.    axy[1] = pxy[1];
  1780.    axy[2] = pxy[2];
  1781.    axy[3] = pxy[3];
  1782.    omx = oldx;
  1783.    omy = oldy;
  1784.  
  1785.    while(planted)
  1786.    {
  1787.  
  1788.       evnt_which = 0;
  1789.       while((evnt_which & MU_BUTTON) == 0)
  1790.       {
  1791.         evnt_which = evnt_multi((MU_BUTTON|MU_M1),
  1792.                  1,1,1,            /* evnt button */
  1793.                  1,oldx,oldy,1,1,    /* evnt_mouse1 */
  1794.                  0,0,0,0,0,
  1795.                  &dummy,
  1796.                  0,0,
  1797.                  &newx,&newy,
  1798.                   &dummy,
  1799.                  &dummy,
  1800.                  &dummy,
  1801.                  &dummy);
  1802.  
  1803.     if((oldx != newx) || (oldy != newy))
  1804.     {
  1805.        do_rule_mark();
  1806.        (*funcs)(xor_handle);
  1807.        pxy[0] += newx - oldx;
  1808.        pxy[1] += newy - oldy;
  1809.            pxy[2] += newx - oldx;
  1810.            pxy[3] += newy - oldy;
  1811.        (*funcs)(xor_handle);
  1812.         }
  1813.         oldx = newx;
  1814.         oldy = newy;
  1815.       }
  1816.  
  1817.       if(!check_dpwork_box(newx,newy))
  1818.       {
  1819.       (*funcs)(xor_handle);            /* erase last drawn */
  1820.           newx = oldx = *gcurx = omx;
  1821.           newy = oldy = *gcury = omy;          
  1822.           Supexec(KICKAES);            /* now adjust system  */
  1823.       pxy[0] = axy[0];            /* restore old array  */
  1824.       pxy[1] = axy[1];
  1825.       pxy[2] = axy[2];
  1826.       pxy[3] = axy[3];
  1827.       (*funcs)(xor_handle);            /* and draw new line  */
  1828.       planted = TRUE;
  1829.       do_rule_mark();
  1830.           BSTATE = 0;
  1831.           event = 0;
  1832.  
  1833.           while( (BREAL == 1) || (BREAL == 2) || (BREAL == 3));    /* sit when button down */
  1834.                             
  1835.                 
  1836.           for(;;)    /* used to bleed off unwanted messages...*/
  1837.           {
  1838.         event = evnt_multi((MU_MESAG|MU_TIMER),
  1839.                     0,0,0,
  1840.                     0,0,0,0,0,
  1841.                     0,0,0,0,0,
  1842.                     tmp_buff,
  1843.                     0,0,        /* timer == 0 */
  1844.                     &dummy,&dummy,
  1845.                     &dummy,&dummy,
  1846.                     &dummy,&dummy);
  1847.  
  1848.         if(event == MU_TIMER)
  1849.                 break;
  1850.           }
  1851.           BSTATE = 0;
  1852.       }
  1853.       else
  1854.      planted = FALSE;
  1855.    }
  1856.    if(snap_to_grids)
  1857.    {
  1858.       snap_to_grid(&pxy[0],&pxy[1]);
  1859.       snap_to_grid(&pxy[2],&pxy[3]);
  1860.    }
  1861.    (*funcs)(shandle);
  1862.    button_end();
  1863. }
  1864.  
  1865.  
  1866. /**************************************************************************/
  1867. /* Function:    do_nada()                          */
  1868. /* Description: Handler for object/region/primitive selections          */
  1869. /**************************************************************************/
  1870. do_nada(mx,my)
  1871. int mx,my;
  1872. {
  1873.    int whandle;
  1874.    int direction;
  1875.    int type;
  1876.    int page;
  1877.    int x1,y1,x2,y2;
  1878.    long txtptr,slvptr;
  1879.    int found;
  1880.    long scanlist;
  1881.    int msg[8];
  1882.    REGION *rptr;
  1883.    REGION *rptr1;
  1884.    int no_go;
  1885.    int bwidth,bheight;
  1886.    int boxmu_w,boxmu_h;
  1887.  
  1888. if(whandle = wind_find(mx,my))
  1889. {
  1890.  if(whandle == prev_handle)
  1891.  {
  1892.    if(check_dpwork_box(mx,my))
  1893.    {
  1894.     
  1895.       scrntomu(mx,my,&nmx,&nmy,0);
  1896.       if(multi_mode && curr_page % 2 && view_size == PADJCNT)
  1897.       {
  1898.        nmx += hpage_size;
  1899.       }
  1900.       if(multi_mode && (nmx >= multi_box[0]) && (nmy >= multi_box[1]) &&
  1901.             (nmx <= multi_box[2]) && (nmy <= multi_box[3]))
  1902.       {
  1903.        do_move_multi(mx,my);        /* Move multiple boxes */
  1904.        return;
  1905.       }
  1906.  
  1907.       if(gl_region_ptr  || gl_grregion_ptr)
  1908.       {
  1909.  
  1910.       if(active_prim)
  1911.           { 
  1912.         edit_prims(mx,my);
  1913.         return;
  1914.           }
  1915.  
  1916.           region_ptr = ((gl_region_ptr) ? (gl_region_ptr):(gl_grregion_ptr));    
  1917.       if(check_boxes(mx,my))
  1918.                return;
  1919.  
  1920.           if(inside_region(nmx,nmy,region_ptr,
  1921.               &rect_in_mu[0],&rect_in_mu[1],
  1922.               &rect_in_mu[2],&rect_in_mu[3],&type,&page))
  1923.           {
  1924.              if( (((page % 2) && alt_offset) ||
  1925.              (!( page % 2) && !alt_offset) && (view_size == PADJCNT)) 
  1926.              || (view_size != PADJCNT))
  1927.              {
  1928.         if(alt_offset)
  1929.             {
  1930.            rect_in_mu[0] += hpage_size;
  1931.            rect_in_mu[2] += hpage_size;
  1932.             }
  1933.                 do_move_region(mx,my,type);
  1934.             return;
  1935.              }
  1936.  
  1937.           }
  1938.       }    
  1939.   } /* if check dpwork_box()      */
  1940.   else
  1941.      active_prim = FALSE;
  1942.  }  /* check if in prev_handle    */
  1943.  else
  1944.      active_prim = FALSE;
  1945. }   /* check if clicked on window */
  1946. else
  1947.      active_prim = FALSE;
  1948.  
  1949.  
  1950.    if(whandle = wind_find(mx,my))
  1951.    {
  1952.       if(whandle == prev_handle)
  1953.       {
  1954.         if(check_dpwork_box(mx,my))
  1955.         {
  1956.             scrntomu(mx,my,&nmx,&nmy,0);
  1957.  
  1958.                        /* alt_offset set by scrntomu()*/
  1959.                 /* 0 - clicked on left page    */
  1960.                 /* 1 - clicked on right page   */
  1961.  
  1962.             if(view_size == PADJCNT)
  1963.         {
  1964.            if(curr_page % 2)        /*right active */
  1965.            no_go = ((!alt_offset)?(TRUE):(FALSE));
  1966.            else                /* left active */
  1967.            no_go = ((!alt_offset)?(FALSE):(TRUE));
  1968.             }
  1969.         else
  1970.            no_go = FALSE;            /* not adjacent pages */
  1971.  
  1972.  
  1973.             if(!no_go)
  1974.         {
  1975.                region_ptr = find_region(nmx,nmy,curr_page,
  1976.                                      &rect_in_mu[0],&rect_in_mu[1],
  1977.                                     &rect_in_mu[2],&rect_in_mu[3],&type);
  1978.  
  1979.  
  1980.            if(alt_offset && (view_size == PADJCNT))
  1981.            {
  1982.           rect_in_mu[0] += hpage_size;
  1983.               rect_in_mu[2] += hpage_size;
  1984.            }
  1985.  
  1986.         }
  1987.         else
  1988.            region_ptr = 0L;
  1989.  
  1990.  
  1991.  
  1992.             if(region_ptr)
  1993.             {
  1994.              do_blit();
  1995.          if((kstat & 0x0001)||(kstat & 0x0002))     /* multi-box */
  1996.          {
  1997.             if(gl_region_ptr)
  1998.             rptr = (REGION *)gl_region_ptr;
  1999.             else if(gl_grregion_ptr)
  2000.             rptr = (REGION *)gl_grregion_ptr;
  2001.             else 
  2002.             rptr = 0L;
  2003.             if(rptr)
  2004.             {
  2005.             rptr->multi_select = 1;
  2006.             }
  2007.             if(rptr || multi_mode)
  2008.             {
  2009.             rptr1 = (REGION *)region_ptr;
  2010.             rptr1->multi_select = 1;
  2011.             calc_multbox(multi_box);
  2012.             multi_mode = 1;
  2013.             gl_region_ptr = gl_grregion_ptr = 0L;
  2014.                  menu_ienable(ad_menu,RCOORD,FALSE);
  2015.                  menu_ienable(ad_menu,OADDPRIM,FALSE);
  2016.                  menu_ienable(ad_menu,RMOVEFNT,FALSE);
  2017.                 menu_ienable(ad_menu,RMOVEBAK,FALSE);
  2018.             }
  2019.          }
  2020.          else
  2021.          {
  2022.             clr_multi_flags(curr_page);
  2023.             multi_mode = 0;
  2024.          }
  2025.          gsx_moff();
  2026.          if(multi_mode)
  2027.          {
  2028.                     mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  2029.                     mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  2030.             do_outer(xor_handle,pxy);     /* don't draw size boxes */
  2031.          }
  2032.          else
  2033.          {
  2034. /*********        if(!mode_flag)         only of non-text display */
  2035.                  menu_ienable(ad_menu,OADDPRIM,TRUE);
  2036.             menu_ienable(ad_menu,RUNLINK,TRUE);
  2037.             menu_ienable(ad_menu,RDELETE,TRUE);
  2038.             menu_ienable(ad_menu,RCOORD,TRUE);
  2039.             menu_ienable(ad_menu,RMOVEFNT,TRUE);
  2040.             menu_ienable(ad_menu,RMOVEBAK,TRUE);
  2041.                     mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  2042.                     mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  2043.             do_outline(xor_handle,pxy);
  2044.          }
  2045.          gsx_mon();
  2046.  
  2047.                  if(!type)
  2048.                  {
  2049.                       gl_region_ptr = region_ptr;
  2050.            gl_grregion_ptr = 0L;
  2051.                    get_txtattr(gl_region_ptr,&gltxtattr);
  2052.                    update_point_dialog();
  2053.  
  2054.                    zdevice = SCANNER;
  2055.                    SH = vmutopix((int)gltxtattr.lnsp);
  2056.            
  2057.  
  2058.            if(kstat & 0x0008)        /* alt click    */
  2059.            {
  2060.             found = 0;
  2061.             scanlist = getf_scaninfo(region_ptr,&x1,&y1,
  2062.                         &x2,&y2,&txtptr,&slvptr);
  2063.             while(scanlist)
  2064.             {
  2065.                 if(nmx >= x1 && nmx <= x2 && nmy >= y1 &&
  2066.                    nmy <= y2)
  2067.                 {
  2068.                 found = 1;
  2069.                 break;
  2070.                 }
  2071.                 scanlist = getn_scaninfo(&x1,&y1,&x2,&y2,
  2072.                     &txtptr,&slvptr);
  2073.             }
  2074.             if(found)
  2075.             {
  2076.                 top_window(txt_handle,txtptr);
  2077.                 wind_get(txt_handle,WF_CURRXYWH,&msg[4],
  2078.                 &msg[5],&msg[6],&msg[7]);
  2079.                 msg[3] = txt_handle;
  2080.                 do_redraw(msg);
  2081.             }
  2082.            }
  2083.             
  2084.                  }
  2085.              else
  2086.                  {
  2087.             gl_grregion_ptr = region_ptr;
  2088.             gl_region_ptr = 0L;
  2089.                     get_grattr(gl_grregion_ptr,glgrattr);
  2090.                     gl_lstyle = glgrattr[0];
  2091.                       gl_lwidth = glgrattr[1];
  2092.                       gl_fstyle = glgrattr[2];
  2093.                       gl_findex = glgrattr[3];
  2094.             gl_repel  = glgrattr[4];
  2095.             gl_repbounds = glgrattr[6];
  2096.             gl_repoffset = glgrattr[5];
  2097.                  }
  2098.              evnt_button(1,1,0,&dummy,&dummy,&dummy,&dummy);
  2099.            }
  2100.            else
  2101.        {
  2102.           if(gl_region_ptr  || gl_grregion_ptr || multi_mode)
  2103.           {
  2104.              check_only_blit();
  2105.           }
  2106.  
  2107.           if(valid_page(curr_page))
  2108.           {
  2109.                 graf_rubbox(mx,my,0,0,&bwidth,&bheight);
  2110.                 scrntomu(bwidth,bheight,&boxmu_w,&boxmu_h,1);
  2111.                 do_calc_multi(nmx,nmy,boxmu_w,boxmu_h);
  2112.           }
  2113.            }
  2114.  
  2115.        }            /* if(check_dpwork_box()     */
  2116.        else
  2117.       check_only_blit();
  2118.       }                /* if whandle == prev_handle */
  2119.    }
  2120.    else
  2121.    {
  2122.     check_only_blit();
  2123.      if(icon_clicked(mx,my))
  2124.        if(animate_icon(mx,&direction))
  2125.           do_flip_page(direction);    
  2126.    }
  2127. }
  2128.  
  2129.  
  2130.  
  2131.  
  2132. do_calc_multi(x,y,w,h)
  2133. int x,y,w,h;
  2134. {
  2135.    int rubbox[4];
  2136.    int rect[4];
  2137.    int pxy[4];
  2138.    register REGION *rptr;
  2139.    int found;
  2140.  
  2141.    found = 0;
  2142.    rptr = curpage->regptr;
  2143.    rubbox[0] = x;
  2144.    rubbox[1] = y;
  2145.    rubbox[2] = x + w - 1;
  2146.    rubbox[3] = y + h - 1;
  2147.    while(rptr)
  2148.    {
  2149.     rect[0] = rptr->x1;
  2150.         rect[1] = rptr->y1;
  2151.         rect[2] = rptr->x2;
  2152.         rect[3] = rptr->y2;
  2153.     if(rect_intersect(rubbox,rect))
  2154.     {
  2155.        found = 1;
  2156.        rptr->multi_select = 1;
  2157.     }
  2158.     rptr = rptr->plink;
  2159.    }
  2160.    multi_mode = found;
  2161.    if(multi_mode)
  2162.    {
  2163.       menu_ienable(ad_menu,RUNLINK,TRUE);
  2164.       menu_ienable(ad_menu,RDELETE,TRUE);
  2165.       calc_multbox(multi_box);
  2166.       mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  2167.       mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  2168.       gsx_moff();
  2169.       do_outer(xor_handle,pxy);     /* don't draw size boxes */
  2170.       gsx_mon();
  2171.    }
  2172. }
  2173.  
  2174. /**************************************************************************/
  2175. /* Function:    screen_clip()                          */
  2176. /* Description:                               */
  2177. /**************************************************************************/
  2178. screen_clip()
  2179. {
  2180.    set_clip(TRUE,&dpwork);
  2181.    grect_to_array(&dpwork,clip_area);
  2182.    vs_clip(xor_handle,TRUE,clip_area);
  2183.    grect_to_array(&pwork,clip_area);
  2184.    vs_clip(rule_handle,TRUE,clip_area);
  2185. }
  2186.  
  2187.  
  2188.  
  2189. /**************************************************************************/
  2190. /* Function: scrn2clip()                          */
  2191. /* Description: Allows clipping settings for PADJCNT              */
  2192. /**************************************************************************/
  2193. scrn2clip()
  2194. {
  2195.   GRECT  tpwork;
  2196.  
  2197.   if(view_size == PADJCNT)
  2198.   {
  2199.        tpwork.g_w = dpwork.g_w / 2;
  2200.        tpwork.g_h = dpwork.g_h;
  2201.        tpwork.g_y = dpwork.g_y;
  2202.        tpwork.g_x = ((curr_page % 2) ? (dpwork.g_x + tpwork.g_w):(dpwork.g_x));
  2203.        set_clip(TRUE,&tpwork);
  2204.   }
  2205.   else
  2206.      set_clip(TRUE,&dpwork);
  2207.   grect_to_array(&dpwork,clip_area);
  2208.   vs_clip(xor_handle,TRUE,clip_area);
  2209.   grect_to_array(&pwork,clip_area);
  2210.   vs_clip(rule_handle,TRUE,clip_area);
  2211.  
  2212.  
  2213. }
  2214.  
  2215.  
  2216.  
  2217. /**************************************************************************/
  2218. /* Function:    poly_handler()                          */
  2219. /* Description: Polygon handler                          */
  2220. /**************************************************************************/
  2221. poly_handler(mx,my)
  2222. int mx,my;
  2223. {
  2224.      pxy[0] = pxyarray[0] = pxyarray[2] = mx;
  2225.      pxy[1] = pxyarray[1] = pxyarray[3] = my;
  2226.      num    = 1;
  2227.      aindex  = 2;
  2228.  
  2229.  
  2230.      while(BSTATE != 2)
  2231.      {
  2232.          while((BSTATE != 1) && (BSTATE != 2) && (BSTATE != 3))
  2233.          {
  2234.             graf_mkstate(&newx,&newy,&button,&key);
  2235.             if((oldx != newx) || (oldy != newy))
  2236.             {
  2237.           if(snap_to_grids)
  2238.          snap_to_grid(&newx,&newy);
  2239.           do_rule_mark();
  2240.               (*funcs)(xor_handle,2);
  2241.           pxyarray[2] = newx;
  2242.               pxyarray[3] = newy;
  2243.               (*funcs)(xor_handle,2);              
  2244.         }
  2245.         oldx = newx;
  2246.         oldy = newy;
  2247.          }
  2248.      
  2249.      if(BSTATE == 1)
  2250.          {
  2251.             v_pline(xor_handle,2,pxyarray);
  2252.             v_pline(xor_handle,2,pxyarray);
  2253.             pxy[aindex++] = pxyarray[2];
  2254.          pxy[aindex++] = pxyarray[3];
  2255.         pxyarray[0] = pxyarray[2];
  2256.         pxyarray[1] = pxyarray[3];
  2257.             num++;
  2258.         BSTATE = 0;
  2259.         if(num > 125)        /* max of 125 vertices */
  2260.           BSTATE = 2;        /* so exit immediately.*/
  2261.          }
  2262.      }
  2263.      evnt_button(1,1,0,&dummy,&dummy,&dummy,&dummy);
  2264.      evnt_button(1,2,0,&dummy,&dummy,&dummy,&dummy);
  2265.      (*funcs)(xor_handle,2);
  2266.      (*funcs)(shandle,num);
  2267.      button_end();
  2268. }
  2269.  
  2270.  
  2271.  
  2272.  
  2273. /**************************************************************************/
  2274. /* Function:    button_end()                          */
  2275. /* Description: Button handler and poly_handler completion routines      */
  2276. /**************************************************************************/
  2277. button_end()
  2278. {
  2279.    int pxy[4];
  2280.  
  2281.    if(view_size == PADJCNT)
  2282.    {
  2283.       pxy[0] = pxy[2] = pagew/2;
  2284.       pxy[1] = 0;
  2285.       pxy[3] = pageh;
  2286.       v_pline(mhandle,2,pxy);
  2287.    }
  2288.  
  2289.    do_blit();
  2290.    set_clip(TRUE,&dpwork);
  2291.    gsx_mon();
  2292.    mclip();
  2293.    wind_update(END_UPDATE);
  2294.    wind_update(END_MCTRL);
  2295.    evnt_button(1,1,0,&dummy,&dummy,&dummy,&dummy);
  2296. }
  2297.  
  2298.  
  2299.  
  2300. /**************************************************************************/
  2301. /* Function:    check_region_ptr                      */
  2302. /* Description: checks for active graphic or text region          */
  2303. /**************************************************************************/
  2304. check_region_ptr()
  2305. {
  2306.     if(gl_region_ptr || gl_grregion_ptr || multi_mode)
  2307.     {
  2308.        if(multi_mode)
  2309.        {
  2310.       clr_multi_flags(curr_page);
  2311.       multi_mode = 0;
  2312.        }
  2313.        region_ptr = gl_grregion_ptr = gl_region_ptr = 0L;
  2314.        active_prim = FALSE;
  2315.        force_blit_redraw(0);
  2316.     }
  2317. }
  2318.  
  2319.  
  2320.  
  2321.  
  2322.  
  2323. /**************************************************************************/
  2324. /* Function:    check_only_blit                          */
  2325. /* Description:    Checks if a blit is all that is needed              */
  2326. /**************************************************************************/
  2327. check_only_blit()
  2328. {
  2329.        gl_grregion_ptr = gl_region_ptr = 0L;
  2330.        if(multi_mode)
  2331.        {
  2332.           clr_multi_flags(curr_page);
  2333.           multi_mode = 0;
  2334.        }
  2335.        menu_ienable(ad_menu,RDELETE,FALSE);
  2336.        menu_ienable(ad_menu,RUNLINK,FALSE);
  2337.        menu_ienable(ad_menu,RCOORD,FALSE);
  2338.        menu_ienable(ad_menu,OADDPRIM,FALSE);
  2339.        menu_ienable(ad_menu,RMOVEFNT,FALSE);
  2340.        menu_ienable(ad_menu,RMOVEBAK,FALSE);
  2341.        do_blit();
  2342. }
  2343.  
  2344.  
  2345.  
  2346.  
  2347. /**************************************************************************/
  2348. /* Function:    do_delregion()                          */
  2349. /* Description:  Delete the currently selected region              */
  2350. /**************************************************************************/
  2351. do_delregion()
  2352. {
  2353. int dummy;
  2354. long tmp;
  2355. long nextregion;
  2356. int rect[4];
  2357.  
  2358.    if((!gl_grregion_ptr)&&(!gl_region_ptr) && !multi_mode)
  2359.    {
  2360.     clear_regprim_flags();
  2361.     return;
  2362.    }
  2363.         if(multi_mode)
  2364.     {
  2365.        do_delmulti();
  2366.        return;
  2367.  
  2368.         }
  2369.     if(gl_grregion_ptr)
  2370.     {
  2371.        find_boundary(gl_grregion_ptr,&rect[0],&rect[1],&rect[2],
  2372.              &rect[3],&dummy,&dummy);
  2373.             tmp = 0L;
  2374.        delete_region(gl_grregion_ptr);
  2375.        gl_grregion_ptr = 0L;
  2376.        update_repel(0,rect);
  2377.     }
  2378.     else
  2379.     {
  2380.        find_boundary(gl_region_ptr,&rect[0],&rect[1],&rect[2],
  2381.              &rect[3],&dummy,&dummy);
  2382.        tmp = get_regart(gl_region_ptr);
  2383.        if(tmp)
  2384.        {
  2385.           curregion = gl_region_ptr;
  2386.           nextregion = prev_aregion(curregion); /* To properly clean up */
  2387.           if(!nextregion)   /* we must get the region before the deleted*/
  2388.                 /* one. If 0L then start from the next one  */
  2389.          nextregion = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  2390.        }        
  2391.        delete_region(gl_region_ptr);
  2392.        
  2393.     }
  2394.     if(tmp)
  2395.     {
  2396.        open_article(tmp);
  2397.        if(nextregion)
  2398.           page_redraw(nextregion);
  2399.        graf_mouse(ARROW,&dummy);
  2400.     }
  2401.  
  2402.     if(view_size == PADJCNT)
  2403.                  force_preview();
  2404.      
  2405.         if((view_size != PADJCNT) && !deferhj)
  2406.         redraw_area(0L,rect,1);
  2407.         clear_regprim_flags();
  2408. }
  2409.  
  2410.  
  2411.  
  2412. do_delmulti()
  2413. {
  2414. int dummy;
  2415. long tmp;
  2416. long nextregion;
  2417. int rect[4];
  2418. register REGION *rptr;
  2419. REGION *nextptr;
  2420. REGION *tmpregion;
  2421.  
  2422.    multi_mode = 0;
  2423.    tmpregion = curregion;
  2424.    rptr = curpage->regptr;
  2425.    while(rptr)
  2426.    {
  2427.       nextptr = rptr->plink;
  2428.       if(rptr->multi_select)
  2429.       {
  2430.     if(rptr->type)
  2431.     {
  2432.        find_boundary(rptr,&rect[0],&rect[1],&rect[2],
  2433.              &rect[3],&dummy,&dummy);
  2434.             tmp = 0L;
  2435.        delete_region(rptr);
  2436.            gl_grregion_ptr = 0L;
  2437.        update_repel(0,rect);
  2438.     }
  2439.     else
  2440.     {
  2441.        find_boundary(rptr,&rect[0],&rect[1],&rect[2],
  2442.              &rect[3],&dummy,&dummy);
  2443.        tmp = get_regart(rptr);
  2444.        if(tmp)
  2445.        {
  2446.           curregion = rptr;
  2447.           nextregion = prev_aregion(curregion);
  2448.           if(!nextregion)
  2449.          nextregion = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  2450.        }        
  2451.        delete_region(rptr);
  2452.     }
  2453.     if(tmp)
  2454.     {
  2455.  
  2456.        open_article(tmp);
  2457.        if(nextregion)
  2458.           page_redraw(nextregion);
  2459.        graf_mouse(ARROW,&dummy);
  2460.     }
  2461.     redraw_area(0L,rect,1);
  2462.       }
  2463.      rptr = nextptr;
  2464.    }
  2465.    curregion = tmpregion;
  2466.    clr_multi_flags(curr_page);
  2467. /*   multi_mode = 0;  */
  2468.    clear_regprim_flags();
  2469. }
  2470.  
  2471.  
  2472. /**************************************************************************/
  2473. /* Function:    do_unlinkreg();                          */
  2474. /* Description:  unlink  the currently selected region    from it's article */
  2475. /**************************************************************************/
  2476. do_unlinkreg()
  2477. {
  2478. int dummy;
  2479. long tmp;
  2480. long nextregion;
  2481. int rect[4];
  2482.  
  2483.    if(multi_mode)
  2484.    {
  2485.     do_multunlink();
  2486.     return;
  2487.    }
  2488.    if(!gl_region_ptr)
  2489.    {
  2490.     clear_regprim_flags();
  2491.     return;
  2492.    }
  2493.    active_prim = FALSE;
  2494.    tmp = get_regart(gl_region_ptr);
  2495.    if(tmp)
  2496.    {
  2497.        find_boundary(gl_region_ptr,&rect[0],&rect[1],&rect[2],
  2498.              &rect[3],&dummy,&dummy);
  2499.        curregion = gl_region_ptr;
  2500.        nextregion = prev_aregion(curregion);
  2501.        if(!nextregion)
  2502.                nextregion = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  2503.    }
  2504.    unlink_region(gl_region_ptr);
  2505.  
  2506.    if(tmp)
  2507.    {
  2508.       graf_mouse(2,&dummy);
  2509.       open_article(tmp);
  2510.       if(nextregion)
  2511.           page_redraw(nextregion);
  2512.       graf_mouse(ARROW,&dummy);
  2513.    }
  2514.    redraw_area(gl_region_ptr,rect,1);
  2515.    clear_regprim_flags();
  2516. }
  2517.  
  2518.  
  2519. do_multunlink()
  2520. {
  2521. int dummy;
  2522. long tmp;
  2523. int rect[4];
  2524. REGION *nextregion;
  2525. register REGION *rptr;
  2526. REGION *tmpregion;
  2527.  
  2528.    multi_mode = 0;
  2529.    tmpregion = curregion;
  2530.    rptr = curpage->regptr;
  2531.    while(rptr)
  2532.    {
  2533.       if(rptr->multi_select)
  2534.       {
  2535.     if(!rptr->type)
  2536.            {
  2537.        tmp = get_regart(rptr);
  2538.        if(tmp)
  2539.        {
  2540.             find_boundary(rptr,&rect[0],&rect[1],&rect[2],
  2541.              &rect[3],&dummy,&dummy);
  2542.           curregion = rptr;
  2543.           nextregion = prev_aregion(curregion);
  2544.           if(!nextregion)
  2545.          nextregion = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  2546.        }        
  2547.        unlink_region(rptr);
  2548.        if(tmp)
  2549.        {
  2550.           open_article(tmp);
  2551.           if(nextregion)
  2552.              page_redraw(nextregion);
  2553.           graf_mouse(ARROW,&dummy);
  2554.              redraw_area(0L,rect,1);
  2555.        }
  2556.         }
  2557.       }
  2558.       rptr = rptr->plink;
  2559.    }
  2560.    curregion = tmpregion;
  2561.    clr_multi_flags(curr_page);
  2562.    clear_regprim_flags();
  2563. }
  2564.  
  2565. /**************************************************************************/
  2566. /* Function:    do_delpage()                          */
  2567. /* Description:  Delete the current page.                  */
  2568. /**************************************************************************/
  2569. do_delpage()
  2570. {
  2571.    register PAGE *pptr;
  2572.    register REGION *rptr;
  2573.  
  2574.    if(alert_cntre(ALERT6) == 1)
  2575.    {    
  2576.     if(valid_page(curr_page))
  2577.         {
  2578.        delete_page();            /* Delete and recalc text ptrs    */
  2579.         }
  2580.         else
  2581.         {
  2582.            pptr = pagehd;        /* all pages AFTER the current one  */
  2583.            do                /* have their page numbers bumped   */
  2584.            {                /* DOWN by 1 due to deletion of page*/
  2585.               if(pptr->pagenum > curr_page)
  2586.               {
  2587.                 pptr->pagenum -= 1;
  2588.                 rptr = pptr->regptr;
  2589.             while(rptr)
  2590.             {
  2591.            rptr->p = pptr->pagenum;
  2592.            rptr = rptr->plink;
  2593.         }
  2594.                 }
  2595.               pptr = pptr->nextpage;
  2596.            }while(pptr != NULLPTR);
  2597.         }
  2598.     recalc_txtptrs();
  2599.     force_preview();
  2600.    }
  2601. }
  2602.     
  2603.  
  2604.  
  2605.  
  2606. /**************************************************************************/
  2607. /* Function: do_move_region()                          */
  2608. /* Description: Handles a selected region that is moved...          */
  2609. /**************************************************************************/
  2610. do_move_region(mx,my,type)
  2611. int mx,my;
  2612. int type;
  2613. {
  2614.          int opcode;
  2615.     int fflag;
  2616.     int fx,fy;
  2617.         register int i;
  2618.     long tregion_ptr;
  2619.     int mbutton;
  2620.     int toggle;
  2621.     int tempx,tempy;
  2622.     int page;
  2623.     int line_flag;
  2624.         int gtype;
  2625.  
  2626.     mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  2627.     mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  2628.  
  2629.     voldx = oldx = mx;
  2630.     voldy = oldy = my;
  2631.     
  2632.     graf_mouse(4,&dummy);
  2633.  
  2634.             
  2635.         line_flag=(((pxy[0]==pxy[2])||(pxy[1]==pxy[3]))?(TRUE):(FALSE));
  2636.  
  2637.     gsx_moff();
  2638.     do_outline(xor_handle,pxy);
  2639.     if(line_flag)
  2640.         do_outer(xor_handle,pxy);
  2641.     else
  2642.         do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2643.     gsx_mon();
  2644.  
  2645.     mbutton = TRUE;
  2646.     while(mbutton)
  2647.     {
  2648.         graf_mkstate(&newx,&newy,&mbutton,&dummy);
  2649.         if((oldx != newx) || (oldy != newy))
  2650.         {
  2651.           gsx_moff();
  2652.           do_rule_mark();
  2653.           if(line_flag)
  2654.             do_outer(xor_handle,pxy);
  2655.           else
  2656.             do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2657.           pxy[0] += newx - oldx;
  2658.           pxy[1] += newy - oldy;
  2659.           pxy[2] += newx - oldx;
  2660.           pxy[3] += newy - oldy;
  2661.           if(line_flag)
  2662.             do_outer(xor_handle,pxy);
  2663.           else
  2664.             do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2665.           gsx_mon();          
  2666.         }
  2667.             oldx = newx;
  2668.         oldy = newy;
  2669.     }
  2670.  
  2671.   if(check_dpwork_box(newx,newy))
  2672.   {    
  2673.     if((voldx != newx) || (voldy != newy))
  2674.     {
  2675.        deltax = newx - voldx;
  2676.        deltay = newy - voldy;
  2677.        fx = ((deltax < 0) ? (-1) : (1));
  2678.        fy = ((deltay < 0) ? (-1) : (1));
  2679.  
  2680.        scrntomu(abs(newx - voldx),abs(newy - voldy),&deltax,&deltay,1);
  2681.  
  2682.        deltax *= fx;
  2683.        deltay *= fy;
  2684.        
  2685.        if(snap_to_grids)
  2686.        {
  2687.         tempx = deltax + rect_in_mu[0];
  2688.         tempy = deltay + rect_in_mu[1];
  2689.         snap_mu(&tempx,&tempy);
  2690.         deltax = tempx - rect_in_mu[0];
  2691.         deltay = tempy - rect_in_mu[1];
  2692.            }       
  2693.  
  2694.            if(kstat & 0x0004)
  2695.            {
  2696.             copy_region();
  2697.             return;
  2698.            }
  2699.  
  2700.        opcode = get_fprimitive(region_ptr,&count,&wmode);
  2701.        fflag = TRUE;
  2702.        while(opcode != -1)
  2703.        {
  2704.         switch(opcode)
  2705.         {
  2706.             case 3:
  2707.             case 4:
  2708.             case 0: toggle = TRUE;
  2709.                     for(i=0;i<(count*2);i++)
  2710.                 {
  2711.                    ptsarray[i] += ((toggle) ? (deltax):(deltay));
  2712.                    toggle ^= TRUE;
  2713.                 }
  2714.                 break;
  2715.  
  2716.             case 1: ptsarray[0] += deltax;
  2717.                 ptsarray[1] += deltay;
  2718.                 break;
  2719.  
  2720.             case 2: ptsarray[0] += deltax;
  2721.                 ptsarray[2] += deltax;
  2722.                 ptsarray[1] += deltay;
  2723.                 ptsarray[3] += deltay;
  2724.                 break;
  2725.        
  2726.         }    /* end of switch(opcode) */
  2727.         update_primitive(opcode,count,wmode,fflag);
  2728.         fflag = FALSE;
  2729.         opcode = get_nprimitive(&count,&wmode);
  2730.        }        /* end of while         */
  2731.  
  2732.        tregion_ptr = region_ptr;
  2733.        graf_mkstate(&mx,&my,&mbutton,&dummy);
  2734.  
  2735.        if(gl_region_ptr)
  2736.        {        
  2737.         page_redraw(region_ptr);
  2738.         gtype = FALSE;
  2739.        }
  2740.        else
  2741.        {
  2742.         update_repel(1,rect_in_mu);
  2743.         gtype = TRUE;
  2744.        }
  2745.          if(view_size != PADJCNT && !deferhj && gl_region_ptr)
  2746.           redraw_area(tregion_ptr,rect_in_mu,1);    /* Cleanup old area */
  2747.        if(gtype)
  2748.         gl_grregion_ptr = tregion_ptr;
  2749.        else
  2750.         gl_region_ptr = tregion_ptr;
  2751.        region_ptr = tregion_ptr;
  2752.        find_boundary(tregion_ptr,
  2753.                   &rect_in_mu[0],&rect_in_mu[1],
  2754.                   &rect_in_mu[2],&rect_in_mu[3],&dummy,&page);
  2755.  
  2756.        if((page % 2) && (view_size == PADJCNT))
  2757.        {
  2758.         alt_offset = TRUE;
  2759.         rect_in_mu[0] += hpage_size;
  2760.         rect_in_mu[2] += hpage_size;
  2761.        }
  2762.        mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  2763.        mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  2764.        gsx_moff();
  2765.        do_outline(xor_handle,pxy);
  2766.        gsx_mon();
  2767.     }
  2768.     else
  2769.     {
  2770.        gsx_moff();
  2771.        do_outline(xor_handle,pxy);
  2772.        do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2773.        gsx_mon();
  2774.     }
  2775.    }
  2776.    else
  2777.    {
  2778.       gsx_moff();
  2779.       do_blit();
  2780.       find_boundary(region_ptr,&rect_in_mu[0],&rect_in_mu[1],
  2781.             &rect_in_mu[2],&rect_in_mu[3],&dummy,&dummy);
  2782.       if((curr_page % 2) && (view_size == PADJCNT))
  2783.       {
  2784.     alt_offset = TRUE;
  2785.     rect_in_mu[0] += hpage_size;
  2786.     rect_in_mu[2] += hpage_size;
  2787.       }
  2788.       mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  2789.       mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  2790.  
  2791.       do_outline(xor_handle,pxy);
  2792.       gsx_mon();
  2793.    }
  2794.     graf_mouse(0,&dummy);
  2795. }
  2796.  
  2797.  
  2798.  
  2799. /**************************************************************************/
  2800. /* Function: do_move_multi()                          */
  2801. /* Description: Handles moving multiple regions                  */
  2802. /**************************************************************************/
  2803. do_move_multi(mx,my)
  2804. int mx,my;
  2805. {
  2806.          int opcode;
  2807.     int fflag;
  2808.     int fx,fy,i;
  2809.     int mbutton;
  2810.     int toggle;
  2811.     long art;
  2812.     int tempx,tempy;
  2813.         register REGION *rptr;
  2814.         int type;
  2815.         long tmpcurregion;
  2816.         register long *rtable;
  2817.         register int rcount;
  2818.         long rtblsize;
  2819.         int line_flag;
  2820.         REGION *saveregion;
  2821.  
  2822.     rcount = 0;
  2823.         rptr = curpage->regptr;
  2824.     while(rptr)            /* How many selected regions ? */
  2825.         {
  2826.        if(rptr->multi_select)
  2827.        {
  2828.         rcount++;
  2829.            }
  2830.            rptr = rptr->plink;
  2831.         }
  2832.         rtblsize = 4L * ((long)rcount + 1L);
  2833.         rtable = (long *)lmalloc(rtblsize);   /* Get table to save them */
  2834.         if(!rtable)
  2835.         {
  2836.        alert_cntre(ALERT12);
  2837.        return;
  2838.         }
  2839.         i = 0;
  2840.         rptr = curpage->regptr;
  2841.     while(rptr)            /* Save selected regions           */ 
  2842.         {                /* They get reset during redraw    */
  2843.        if(rptr->multi_select)    /* and this is the only case where */
  2844.        {                /* we want to preserve them        */
  2845.         rtable[i++] = (long)rptr;
  2846.            }
  2847.            rptr = rptr->plink;
  2848.         }
  2849.              
  2850.     mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  2851.     mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  2852.  
  2853.     voldx = oldx = mx;
  2854.     voldy = oldy = my;
  2855.     
  2856.     graf_mouse(4,&dummy);
  2857.  
  2858.         line_flag=(((pxy[0]==pxy[2])||(pxy[1]==pxy[3]))?(TRUE):(FALSE));
  2859.  
  2860.     gsx_moff();
  2861.     if(!line_flag)
  2862.     {
  2863.       do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2864.       do_outer(xor_handle,pxy);
  2865.     }
  2866.  
  2867.     gsx_mon();
  2868.     
  2869.     mbutton = TRUE;
  2870.     while(mbutton)
  2871.     {
  2872.         graf_mkstate(&newx,&newy,&mbutton,&dummy);
  2873.         if((oldx != newx) || (oldy != newy))
  2874.         {
  2875.           gsx_moff();
  2876.           do_rule_mark();
  2877.           if(line_flag)
  2878.             do_outer(xor_handle,pxy);
  2879.           else        
  2880.               do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2881.           pxy[0] += newx - oldx;
  2882.           pxy[1] += newy - oldy;
  2883.           pxy[2] += newx - oldx;
  2884.           pxy[3] += newy - oldy;
  2885.           if(line_flag)
  2886.             do_outer(xor_handle,pxy);
  2887.           else
  2888.               do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  2889.           gsx_mon();          
  2890.         }
  2891.             oldx = newx;
  2892.         oldy = newy;
  2893.     }
  2894.  
  2895.     if(check_dpwork_box(newx,newy))
  2896.     {
  2897.     if((voldx != newx) || (voldy != newy))
  2898.     {
  2899.        deltax = newx - voldx;
  2900.        deltay = newy - voldy;
  2901.        fx = ((deltax < 0) ? (-1) : (1));
  2902.        fy = ((deltay < 0) ? (-1) : (1));
  2903.  
  2904.        scrntomu(abs(newx - voldx),abs(newy - voldy),&deltax,&deltay,1);
  2905.  
  2906.        deltax *= fx;
  2907.        deltay *= fy;
  2908.        
  2909.        if(snap_to_grids)
  2910.        {
  2911.         tempx = deltax + multi_box[0];
  2912.         tempy = deltay + multi_box[1];
  2913.         snap_mu(&tempx,&tempy);
  2914.         deltax = tempx - multi_box[0];
  2915.         deltay = tempy - multi_box[1];
  2916.            }       
  2917.        tmpcurregion = curregion;
  2918.  
  2919.            if(kstat & 0x004)
  2920.        {
  2921.           for(i = 0;i < rcount;i++)
  2922.         {
  2923.            curregion = rtable[i];
  2924.            copy_region();
  2925.         }
  2926.  
  2927.             for(i = 0;i < rcount;i++)
  2928.                 {
  2929.                rptr = (REGION *)rtable[i];
  2930.                rptr->multi_select = 1;
  2931.                 }
  2932.            free(rtable);
  2933.  
  2934.         curregion = 0L;
  2935.                 multi_mode = 1;
  2936.                 gl_region_ptr = gl_grregion_ptr = 0L;
  2937.             mcalc_multbox(multi_box);
  2938.  
  2939.             if((curr_page % 2) && (view_size == PADJCNT))
  2940.             {
  2941.            alt_offset = TRUE;
  2942.            multi_box[0] += hpage_size;
  2943.            multi_box[2] += hpage_size;
  2944.             }
  2945.         
  2946.             mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  2947.             mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  2948.             gsx_moff();
  2949.             do_outer(xor_handle,pxy);
  2950.             gsx_mon();
  2951.         return;
  2952.        }
  2953.            rptr = get_fregion(curr_page,&rect_in_mu[0],&rect_in_mu[1],
  2954.                   &rect_in_mu[2],&rect_in_mu[3],&type);
  2955.            while(rptr)
  2956.            {
  2957.           if(rect_in_mu[0] >= hpage_size)    /* clip it out! */
  2958.                     goto next;
  2959.  
  2960.           curregion = (long)rptr;
  2961.           if(rptr->multi_select)
  2962.               {
  2963.              opcode = get_fprimitive(rptr,&count,&wmode);
  2964.              fflag = TRUE;
  2965.              while(opcode != -1)
  2966.              {
  2967.             switch(opcode)
  2968.             {
  2969.                case 3:
  2970.                case 4:
  2971.                case 0: 
  2972.                 toggle = TRUE;
  2973.                     for(i=0;i<(count*2);i++)
  2974.                 {
  2975.                    ptsarray[i] += ((toggle) ? (deltax):(deltay));
  2976.                    toggle ^= TRUE;
  2977.                 }
  2978.                 break;
  2979.  
  2980.                case 1: 
  2981.                             ptsarray[0] += deltax;
  2982.                 ptsarray[1] += deltay;
  2983.                 break;
  2984.  
  2985.                case 2: 
  2986.                             ptsarray[0] += deltax;
  2987.                 ptsarray[2] += deltax;
  2988.                 ptsarray[1] += deltay;
  2989.                 ptsarray[3] += deltay;
  2990.                 break;
  2991.        
  2992.             }    /* end of switch(opcode) */
  2993.            update_primitive(opcode,count,wmode,fflag);
  2994.            fflag = FALSE;
  2995.            opcode = get_nprimitive(&count,&wmode);
  2996.              }        /* end of while         */
  2997.              if(!rptr->type)
  2998.              {
  2999.             art = get_regart(rptr);
  3000.             if(art)
  3001.             {
  3002.                saveregion = sfregion;
  3003.                open_article(art);
  3004.                do_artcleanup(rptr,0);
  3005.                sfregion = saveregion;
  3006.             }
  3007.              }
  3008.           }
  3009. next:          rptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  3010.               &rect_in_mu[2],&rect_in_mu[3],&type);
  3011.            }
  3012.            curregion = tmpcurregion;
  3013.  
  3014.            force_preview();
  3015.            for(i = 0;i < rcount;i++)
  3016.            {
  3017.           rptr = (REGION *)rtable[i];
  3018.           rptr->multi_select = 1;
  3019.            }
  3020.        free(rtable);
  3021.            multi_mode = 1;
  3022.        mcalc_multbox(multi_box);
  3023.  
  3024.        if((curr_page % 2) && (view_size == PADJCNT))
  3025.        {
  3026.         alt_offset = TRUE;
  3027.         multi_box[0] += hpage_size;
  3028.         multi_box[2] += hpage_size;
  3029.        }
  3030.        mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  3031.        mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  3032.        gsx_moff();
  3033.        do_outer(xor_handle,pxy);
  3034.        gsx_mon();
  3035.     }
  3036.     else
  3037.     {
  3038.        gsx_moff();
  3039.        do_outer(xor_handle,pxy);
  3040.        do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3041.        gsx_mon();
  3042.     }
  3043.    }
  3044.    else
  3045.    {
  3046.       gsx_moff();
  3047.       do_blit();
  3048.       mutoscrn(multi_box[0],multi_box[1],&pxy[0],&pxy[1],0);
  3049.       mutoscrn(multi_box[2],multi_box[3],&pxy[2],&pxy[3],0);
  3050.       do_outer(xor_handle,pxy);
  3051.       gsx_mon();
  3052.    }
  3053.     graf_mouse(0,&dummy);
  3054. }
  3055.  
  3056.  
  3057.  
  3058.  
  3059. /**************************************************************************/
  3060. /* Function: check_boxes();                          */
  3061. /* Description: Selects a box of a selected region.              */
  3062. /**************************************************************************/
  3063. check_boxes(mx,my)
  3064. int mx,my;
  3065. {
  3066.     int type;
  3067.     int dflag;
  3068.     register int pos;
  3069.     int tpxy[4];
  3070.     int old_width,old_height;
  3071.     int new_width,new_height;
  3072.     int opcode,fflag;
  3073.         register int i;
  3074.     int mbutton;
  3075.         int odeltax,odeltay;
  3076.     int ndeltax,ndeltay;
  3077.         int old_murect[4];
  3078.     int new_murect[4];
  3079.     int temp;
  3080.     long tregion_ptr;
  3081.     int page;
  3082.     long treg_ptr;
  3083.         int dummy;    
  3084.  
  3085.     mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  3086.         mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  3087.  
  3088.     dflag = FALSE;
  3089.     tpxy[0] = pxy[0];
  3090.     tpxy[1] = pxy[1];
  3091.     tpxy[2] = pxy[2];
  3092.     tpxy[3] = pxy[3];
  3093.  
  3094.     for(pos=0;pos<8;pos++)
  3095.     {
  3096.       if( (mx >= mboxx1[pos]) &&
  3097.           (mx <= mboxx2[pos]) &&
  3098.           (my >= mboxy1[pos]) &&
  3099.           (my <= mboxy2[pos])
  3100.         )
  3101.       {
  3102.          graf_mouse(3,&dummy);
  3103.          dflag = TRUE;
  3104.          break;
  3105.       }
  3106.     }
  3107.  
  3108.     if(dflag)
  3109.     {
  3110.        oldx = mx;
  3111.        oldy = my;
  3112.  
  3113.        gsx_moff();
  3114.        do_outline(xor_handle,pxy);
  3115.        (*adj_mouse[pos])();        /* shift mouse */
  3116.        Supexec(KICKAES);
  3117.        do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3118.        gsx_mon();
  3119.  
  3120.        mbutton = TRUE;
  3121.        while(mbutton)
  3122.        {
  3123.           graf_mkstate(&newx,&newy,&mbutton,&dummy);
  3124.           if((oldx != newx) || (oldy != newy))
  3125.           {
  3126.          gsx_moff();
  3127.          do_rule_mark();
  3128.              do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3129.          (*da_box[pos])();
  3130.              do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3131.          gsx_mon();
  3132.           }
  3133.           oldx = newx;
  3134.           oldy = newy;
  3135.        }
  3136.        graf_mouse(2,&dummy);    
  3137.  
  3138.  
  3139.        if(pxy[2] < pxy[0])        /* If x2 < x1 then swap     */
  3140.          {
  3141.             temp = pxy[0];
  3142.         pxy[0] = pxy[2];
  3143.         pxy[2] = temp;
  3144.        }
  3145.        if(pxy[3] < pxy[1])
  3146.        {
  3147.         temp = pxy[1];
  3148.         pxy[1] = pxy[3];
  3149.         pxy[3] = temp;
  3150.        }
  3151.        if(snap_to_grids)
  3152.        {
  3153.         snap_to_grid(&pxy[0],&pxy[1]);
  3154.         snap_to_grid(&pxy[2],&pxy[3]);
  3155.        }
  3156.     
  3157.         treg_ptr = ((gl_region_ptr) ? (gl_region_ptr):(gl_grregion_ptr));
  3158.        find_page(treg_ptr,&page);
  3159.  
  3160.        alt_offset = (((page % 2)&&(view_size == PADJCNT))?(TRUE):(FALSE));
  3161.  
  3162.        scrn2mu(tpxy[0],tpxy[1],&old_murect[0],&old_murect[1],0,alt_offset);
  3163.        scrn2mu(tpxy[2],tpxy[3],&old_murect[2],&old_murect[3],0,alt_offset);
  3164.        scrn2mu(pxy[0],pxy[1],&new_murect[0],&new_murect[1],0,alt_offset);
  3165.        scrn2mu(pxy[2],pxy[3],&new_murect[2],&new_murect[3],0,alt_offset);
  3166.  
  3167.        gsx_moff();
  3168.            (*bdj_mouse[pos])();        /* shift mouse */
  3169.            if(*gcurx < 0) *gcurx = 0;
  3170.         if(*gcurx >= sxres) *gcurx = sxres - 1;
  3171.            if(*gcury < 0) *gcury = 0;
  3172.              if(*gcury >= syres) *gcury = syres - 1;
  3173.               Supexec(KICKAES);
  3174.            gsx_mon();
  3175.  
  3176.        if((voldx != newx) || (voldy != newy))
  3177.        {
  3178.  
  3179.         old_width = old_murect[2] - old_murect[0] + 1;
  3180.         old_height = old_murect[3] - old_murect[1] + 1;
  3181.  
  3182.         new_width = new_murect[2] - new_murect[0];
  3183.         new_height = new_murect[3] - new_murect[1];
  3184.         opcode = get_fprimitive(region_ptr,&count,&wmode);
  3185.         fflag = TRUE;
  3186.         while(opcode != -1)
  3187.          {
  3188.             switch(opcode)
  3189.             {
  3190.             case 0: 
  3191.             case 3:
  3192.             case 4:
  3193.                 i=0;
  3194.                 while(i<count*2)
  3195.                 {
  3196.                    odeltax = ptsarray[i] - old_murect[0];
  3197.                    ndeltax = scale_iv(odeltax,new_width,
  3198.                     old_width); 
  3199.                    ptsarray[i++] = new_murect[0] + ndeltax;
  3200.  
  3201.                    odeltay = ptsarray[i] - old_murect[1];
  3202.                    ndeltay = scale_iv(odeltay,new_height,
  3203.                     old_height);
  3204.                    ptsarray[i++] = new_murect[1] + ndeltay;
  3205.                 }
  3206.                 break;
  3207.  
  3208.             case 1: case12_scale(old_murect[0],
  3209.                          old_murect[1],
  3210.                          old_width,old_height,
  3211.                          new_murect[0],
  3212.                          new_murect[1],
  3213.                          new_width,
  3214.                          new_height,1);
  3215.                 break;
  3216.  
  3217.             case 2: case12_scale(old_murect[0],
  3218.                          old_murect[1],
  3219.                          old_width,old_height,
  3220.                          new_murect[0],
  3221.                          new_murect[1],
  3222.                          new_width,
  3223.                          new_height,2);
  3224.                 break;
  3225.             }
  3226.             update_primitive(opcode,count,wmode,fflag);
  3227.             fflag = FALSE;
  3228.             opcode = get_nprimitive(&count,&wmode);
  3229.         }
  3230.            tregion_ptr = region_ptr;
  3231.         if(gl_region_ptr)
  3232.         {
  3233.            page_redraw(gl_region_ptr);
  3234.            type = FALSE;
  3235.         }
  3236.         else
  3237.         {
  3238.            update_repel(1,old_murect);
  3239.            type = TRUE;
  3240.          }
  3241.          if(view_size != PADJCNT && !deferhj && gl_region_ptr)
  3242.           redraw_area(tregion_ptr,old_murect,1);    /* Cleanup old area */        
  3243.        if(type)
  3244.         gl_grregion_ptr = tregion_ptr;
  3245.        else
  3246.         gl_region_ptr = tregion_ptr;
  3247.        region_ptr = tregion_ptr;
  3248.        find_boundary(tregion_ptr,
  3249.                   &rect_in_mu[0],&rect_in_mu[1],
  3250.                   &rect_in_mu[2],&rect_in_mu[3],&dummy,&page);
  3251.        if((page % 2) && (view_size == PADJCNT))
  3252.        {
  3253.         rect_in_mu[0] += hpage_size;
  3254.         rect_in_mu[2] += hpage_size;
  3255.        }
  3256.        mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  3257.        mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  3258.        gsx_moff();
  3259.        do_outline(xor_handle,pxy);
  3260.        gsx_mon();
  3261.            }
  3262.     }
  3263.     graf_mouse(0,&dummy);
  3264.         return(dflag);
  3265. }
  3266.  
  3267.  
  3268.  
  3269.  
  3270. /**************************************************************************/
  3271. /* Function: do_rule_mark()                          */
  3272. /* Description: Handles the ruler markers                  */
  3273. /**************************************************************************/
  3274. do_rule_mark()
  3275. {
  3276.    int thandle;
  3277.    int dummy;
  3278.    int pts[4];
  3279.    int temp;
  3280.    int temp_mouse;
  3281.  
  3282.    if(!ruler_flag)
  3283.     return;
  3284.    if(newx < dpwork.g_x)
  3285.      return;
  3286.    if(newy < dpwork.g_y)
  3287.     return;
  3288.    temp = dpwork.g_x + dpwork.g_w - 1;
  3289.    if(newx > temp)
  3290.     return;
  3291.    temp = dpwork.g_y + dpwork.g_h - 1;
  3292.    if(newy > temp)
  3293.     return;
  3294.  
  3295.    wind_get(0,WF_TOP,&thandle,&dummy,&dummy,&dummy);
  3296.    if(thandle != prev_handle)
  3297.         return;
  3298.     
  3299.    temp_mouse = mouse_on;
  3300.    if(mouse_on)
  3301.       gsx_moff();
  3302.    pts[1] = pwork.g_y;            /* Erase horizontal mark    */
  3303.    pts[3] = pts[1] + vhalf;
  3304.    if(xold_mark >= 0)
  3305.    {
  3306.       pts[0] = pts[2] = xold_mark;
  3307.       v_pline(rule_handle,2,pts);
  3308.    }
  3309.    pts[0] = pts[2] =  newx;
  3310.    v_pline(rule_handle,2,pts);        /* Draw new horizontal mark    */
  3311.    xold_mark = newx;            /* Save x for erasing later    */
  3312.  
  3313.    pts[0] = pwork.g_x;
  3314.    pts[2] = pts[0] + hhalf;
  3315.    if(yold_mark >= 0)
  3316.    {
  3317.       pts[1] = pts[3] =  yold_mark;
  3318.       v_pline(rule_handle,2,pts);    /* Erase old vertical mark    */
  3319.    }
  3320.    pts[1] = pts[3] = newy;
  3321.    v_pline(rule_handle,2,pts);        /* Draw new vertical mark    */
  3322.    yold_mark = newy;            /* Save for erasing later       */
  3323.    if(temp_mouse)
  3324.       gsx_mon();
  3325. }
  3326.  
  3327.  
  3328.  
  3329.  
  3330. rect_intersect(rect,grect)
  3331. int rect[];
  3332. int grect[];
  3333. {
  3334.     int x1,y1,x2,y2;
  3335.     x2 = min(rect[2],grect[2]);
  3336.     y2 = min(rect[3],grect[3]);
  3337.     x1 = max(rect[0],grect[0]);
  3338.     y1 = max(rect[1],grect[1]);
  3339.     return(x2 >= x1 && y2 >= y1);
  3340. }
  3341.  
  3342.  
  3343.  
  3344.  
  3345. long first_aregion(reg1,reg2,art)
  3346. long reg1,reg2;
  3347. long art;
  3348. {
  3349.    long rptr;
  3350.    long tmpreg;
  3351.    int dummy;
  3352.    long tmpart;
  3353.    long firstreg;
  3354.    
  3355.    firstreg = 0L;
  3356.    tmpart = curart;
  3357.    curart = art;
  3358.    tmpreg = curregion;
  3359.    rptr = getf_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  3360.    while(rptr)
  3361.    {
  3362.     if(rptr == reg1)
  3363.     {
  3364.        firstreg = reg1;
  3365.        break;
  3366.     }
  3367.         if(rptr == reg2)
  3368.     {
  3369.        firstreg = reg2;
  3370.        break;
  3371.         }
  3372.         rptr = getn_aregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  3373.    }
  3374.    curregion = tmpreg;
  3375.    curart = tmpart;
  3376.    return firstreg;
  3377. }
  3378.  
  3379.  
  3380.  
  3381.  
  3382.  
  3383. /**************************************************************************/
  3384. /* Function: update_repel()                          */
  3385. /* Description: Repels new region for flowing of text              */
  3386. /*     Check each text region to see if it intersects with the affected  */
  3387. /*    graphic region.  If it does, put it's article into the list of    */
  3388. /*    articles that need to be redrawn if...1) a previous region did    */
  3389. /*      not have the same article and 2) that previous region was linked  */
  3390. /*    after the current one.  In other words, make sure all intersecting*/
  3391. /*    regions are redrawn at least once but not more than once      */
  3392. /**************************************************************************/
  3393. update_repel(check,oldrect)
  3394. int check;
  3395. int oldrect[];
  3396. {
  3397.    int grattr[11];
  3398.    long tmprptr;
  3399.    int rect[4];
  3400.    int gflag;
  3401.    int grect[4];
  3402.    int redraw_rect[4];
  3403.    int dummy;
  3404.    long art;
  3405.    int found;
  3406.    long mouse_ptr;
  3407.    REGION *saveregion;
  3408.    
  3409.    graf_mouse(2,&mouse_ptr);        /* Busy bee */
  3410.    if(gl_grregion_ptr)
  3411.       find_boundary(gl_grregion_ptr,&grect[0],&grect[1],&grect[2],
  3412.             &grect[3],&dummy,&dummy);
  3413.    if(gl_grregion_ptr && view_size != PADJCNT)
  3414.    {
  3415.       if(oldrect && rect_intersect(oldrect,grect))
  3416.       {
  3417.         redraw_rect[0] = min(grect[0],oldrect[0]);
  3418.      redraw_rect[1] = min(grect[1],oldrect[1]);
  3419.         redraw_rect[2] = max(grect[2],oldrect[2]);
  3420.         redraw_rect[3] = max(grect[3],oldrect[3]);
  3421.         redraw_area(gl_grregion_ptr,redraw_rect,1);
  3422.       }
  3423.       else
  3424.       {
  3425.         if(oldrect)
  3426.            redraw_area(gl_grregion_ptr,oldrect,1);
  3427.         redraw_area(gl_grregion_ptr,grect,1);
  3428.       }
  3429.    }
  3430.    else
  3431.       if(gl_grregion_ptr && oldrect && view_size != PADJCNT)
  3432.          redraw_area(gl_grregion_ptr,oldrect,1);
  3433.    if(check)        /* If flow through, don't re H and J */
  3434.    {
  3435.       get_grattr(gl_grregion_ptr,grattr);
  3436.       if(!grattr[4])
  3437.       {
  3438.      if(view_size == PADJCNT)
  3439.        force_preview();
  3440.      graf_mouse(ARROW,&mouse_ptr);            /* Busy bee */
  3441.      return;
  3442.       }
  3443.    }
  3444.    tmprptr = gl_region_ptr;
  3445.  
  3446.    gl_region_ptr = get_fregion(curr_page,&rect[0],&rect[1],&rect[2],
  3447.                 &rect[3],&gflag);
  3448.    while(gl_region_ptr)
  3449.    {
  3450.       if(rect[0] >= hpage_size)    /* clip it out! */
  3451.            goto next;
  3452.  
  3453.       art = get_regart(gl_region_ptr);
  3454.       if((!gflag && art && gl_grregion_ptr && rect_intersect(rect,grect)) || 
  3455.      (!gflag && art && oldrect && rect_intersect(oldrect,rect)))
  3456.       {
  3457.       saveregion = sfregion;
  3458.       page_redraw(gl_region_ptr);
  3459.       sfregion = saveregion;
  3460.       }
  3461. next: gl_region_ptr = get_nregion(&rect[0],&rect[1],&rect[2],&rect[3],&gflag);    
  3462.    }
  3463.    if(view_size == PADJCNT)
  3464.     force_preview();
  3465.    gl_region_ptr = tmprptr;
  3466.    graf_mouse(ARROW,&mouse_ptr);        /* Busy bee */
  3467. }
  3468.  
  3469.  
  3470.  
  3471.  
  3472. /**************************************************************************/
  3473. /* Function: snap_to_grid()                          */
  3474. /* Description: snaps vertices to a specific grid              */
  3475. /**************************************************************************/
  3476. snap_to_grid(sx,sy)
  3477. int *sx;
  3478. int *sy;
  3479. {
  3480.    int hremain;
  3481.    int vremain;
  3482.    int mux,muy;
  3483.  
  3484.    if(sx < 0 || sy < 0)
  3485.     return;
  3486.  
  3487.    scrntomu(*sx,*sy,&mux,&muy,0);
  3488.    hremain = mux % hgridspace;
  3489.    vremain = muy % vgridspace;     
  3490.    mux /= hgridspace;
  3491.    mux *= hgridspace;
  3492.    muy /= vgridspace;
  3493.    muy *= vgridspace;
  3494.  
  3495.    if(hremain >= hgridspace/2)
  3496.     mux += hgridspace;
  3497.    if(vremain >= vgridspace/2)
  3498.     muy += vgridspace;   
  3499.  
  3500.    mutoscrn(mux,muy,sx,sy,0);
  3501. }
  3502.  
  3503.  
  3504.  
  3505.  
  3506. /**************************************************************************/
  3507. /* Function: snap_mu()                              */
  3508. /* Description: Snaps vertice in mu...        ???              */
  3509. /**************************************************************************/
  3510. snap_mu(mux,muy)
  3511. register int *mux;
  3512. register int *muy;
  3513. {
  3514.    int hremain;
  3515.    int vremain;
  3516.  
  3517.    if(*mux < 0 || *muy < 0)
  3518.     return;
  3519.    hremain = *mux % hgridspace;
  3520.    vremain = *muy % vgridspace;     
  3521.    *mux /= hgridspace;
  3522.    *mux *= hgridspace;
  3523.    *muy /= vgridspace;
  3524.    *muy *= vgridspace;
  3525.  
  3526.    if(hremain >= hgridspace/2)
  3527.     *mux += hgridspace;
  3528.    if(vremain >= vgridspace/2)
  3529.     *muy += vgridspace;   
  3530. }
  3531.  
  3532.  
  3533. /**************************************************************************/
  3534. /* Function: do_edit_prim()                           */
  3535. /* Description: Select with right button a primitive to edit          */
  3536. /**************************************************************************/
  3537. do_edit_prim()
  3538. {
  3539.    int opcode;
  3540.    int minx,miny,maxx,maxy;
  3541.    int page;
  3542.    int pcount;
  3543.    int type;
  3544.  
  3545.    if(gl_region_ptr  || gl_grregion_ptr)
  3546.    {
  3547.       region_ptr = ((gl_region_ptr)?(gl_region_ptr):(gl_grregion_ptr));
  3548.  
  3549.       if(!active_prim)                    /* get first prim...*/
  3550.     opcode = get_fprimitive(region_ptr,&pcount,&wmode);
  3551.       else                        /* get next prim    */
  3552.         opcode = get_nprimitive(&pcount,&wmode);
  3553.         
  3554.       do_blit();
  3555.       if(opcode != -1)                /* outline primitive */
  3556.       {
  3557.     calc_prim(opcode,&minx,&miny,&maxx,&maxy,pcount);
  3558.     active_prim = TRUE;
  3559.     menu_ienable(ad_menu,ODELPRIM,TRUE);
  3560.     menu_ienable(ad_menu,OPCOORD,TRUE);
  3561.         menu_ienable(ad_menu,OMOVEFNT,TRUE);
  3562.     menu_ienable(ad_menu,OMOVEBAK,TRUE);
  3563.     find_page(region_ptr,&page);
  3564.     region_ptr = get_curreg(&type);
  3565.       }
  3566.       else                    /* out of primitives      */
  3567.       {
  3568.     find_boundary(region_ptr,&minx,&miny,
  3569.                  &maxx, &maxy,&dummy,&page);
  3570.     menu_ienable(ad_menu,ODELPRIM,FALSE);
  3571.     menu_ienable(ad_menu,OPCOORD,FALSE);
  3572.         menu_ienable(ad_menu,OMOVEFNT,FALSE);
  3573.         menu_ienable(ad_menu,OMOVEBAK,FALSE);
  3574.         active_prim = FALSE;
  3575.       }
  3576.       outline_primman(minx,miny,maxx,maxy,type,page);
  3577.    }
  3578.    evnt_button(1,1,0,&dummy,&dummy,&dummy,&dummy);
  3579. }
  3580.  
  3581.  
  3582.  
  3583.  
  3584. /**************************************************************************/
  3585. /* Function: calc_prim()                          */
  3586. /* Description: Calculate boundary rectangle of the current primitive     */
  3587. /**************************************************************************/
  3588. calc_prim(op,minx,miny,maxx,maxy,count)
  3589. int op;
  3590. int *minx,*miny,*maxx,*maxy;
  3591. register int count;
  3592. {
  3593.      register int i;
  3594.      int tcount;
  3595.  
  3596.      tcount = count;
  3597.  
  3598.      if(op == 1)            /* ELLIPSE - CIRCLE */
  3599.      {
  3600.     *minx = ptsarray[0] - ptsarray[2];
  3601.         *maxx = ptsarray[0] + ptsarray[2];
  3602.     *miny = ptsarray[1] - ptsarray[3];
  3603.         *maxy = ptsarray[1] + ptsarray[3];
  3604.      }
  3605.      else
  3606.      {                    /* poly,lines, and boxes...*/
  3607.         if((op == 0) || (op == 3) || (op == 4))
  3608.         {
  3609.        i = 0;
  3610.            --count;
  3611.        *minx = *maxx = ptsarray[i++];
  3612.        *miny = *maxy = ptsarray[i++];
  3613.            while(count--)
  3614.            {
  3615.           if(ptsarray[i] > *maxx)
  3616.             *maxx = ptsarray[i];
  3617.               if(ptsarray[i] < *minx)
  3618.             *minx = ptsarray[i];
  3619.           i++;
  3620.               if(ptsarray[i] > *maxy)
  3621.             *maxy = ptsarray[i];
  3622.           if(ptsarray[i] < *miny)
  3623.             *miny = ptsarray[i];
  3624.           i++;
  3625.        }
  3626.         }
  3627.         else
  3628.         {
  3629.        if(op == 2)        /* Graphic images       */
  3630.        {
  3631.         *minx = ptsarray[0];
  3632.         *miny = ptsarray[1];
  3633.         *maxx = ptsarray[2];
  3634.             *maxy = ptsarray[3];
  3635.        }
  3636.         }
  3637.      }
  3638.      count = tcount;
  3639. }
  3640.  
  3641.  
  3642.  
  3643.  
  3644.  
  3645. /**************************************************************************/
  3646. /* Function: edit_prims()                          */
  3647. /* Description: Move and Size Primitives...                  */
  3648. /**************************************************************************/
  3649. edit_prims(mx,my)
  3650. int mx,my;
  3651. {
  3652.      int nmx,nmy;
  3653.  
  3654.      if(check_prim_box(mx,my))
  3655.      {
  3656.     region_ptr = ((gl_region_ptr)?(gl_region_ptr):(gl_grregion_ptr));
  3657.     active_prim = TRUE;
  3658.     return;
  3659.      }
  3660.      scrntomu(mx,my,&nmx,&nmy,0);
  3661.      if(inside_primitive(nmx,nmy))
  3662.      {
  3663.     move_prim_box(mx,my);
  3664.     active_prim = TRUE;
  3665.     return;
  3666.      }
  3667.      menu_ienable(ad_menu,ODELPRIM,FALSE);
  3668.      menu_ienable(ad_menu,OPCOORD,FALSE);
  3669.      menu_ienable(ad_menu,OMOVEFNT,FALSE);
  3670.      menu_ienable(ad_menu,OMOVEBAK,FALSE);
  3671.  
  3672. /*     router_selected(); Deleted because this means it was outside the box*/
  3673. /*   hence, no item is now selected                       */
  3674.  
  3675.      active_prim = FALSE;        
  3676.      check_only_blit();          /* clears menu items and blits to screen */
  3677. }
  3678.  
  3679.  
  3680.  
  3681.  
  3682.  
  3683. /**************************************************************************/
  3684. /* Function: check_prim_box()                          */
  3685. /* Description: Size a primitve                          */
  3686. /**************************************************************************/
  3687. check_prim_box(mx,my)
  3688. int mx,my;
  3689. {
  3690.       int dflag;
  3691.       register int pos;
  3692.       int tpxy[4];
  3693.       int mbutton;
  3694.       int temp;
  3695.       int opcode;
  3696.       int page;
  3697.       int old_width,old_height;
  3698.       int new_width,new_height;
  3699.       int odeltax,odeltay;
  3700.       int ndeltax,ndeltay;
  3701.       int old_murect[4];
  3702.       int new_murect[4];
  3703.       register int i;
  3704.       int topcode;
  3705.       int pcount;
  3706.       int minx,miny,maxx,maxy;
  3707.  
  3708.       dflag = FALSE;
  3709.  
  3710.       topcode = opcode = get_cur_prim(&pcount,&wmode,&prim_ptr);
  3711.       calc_prim(opcode,&minx,&miny,&maxx,&maxy,pcount);
  3712.  
  3713.       if(alt_offset)
  3714.       {
  3715.     minx += hpage_size;
  3716.     maxx += hpage_size;
  3717.       }
  3718.  
  3719.       mutoscrn(minx,miny,&pxy[0],&pxy[1],0);
  3720.       mutoscrn(maxx,maxy,&pxy[2],&pxy[3],0);
  3721.  
  3722.       tpxy[0] = pxy[0];        /* where the hell do these #s come from?*/
  3723.       tpxy[1] = pxy[1];        /* from outline_primman();        */
  3724.       tpxy[2] = pxy[2];        /* aka do_edit_prims();            */
  3725.       tpxy[3] = pxy[3];
  3726.  
  3727.       for(pos=0;pos<8;pos++)
  3728.       {
  3729.     if( (mx >= mboxx1[pos]) &&    /* setup by outline_primman()    */
  3730.         (mx <= mboxx2[pos]) &&
  3731.         (my >= mboxy1[pos]) &&
  3732.         (my <= mboxy2[pos])
  3733.           )
  3734.         {
  3735.         graf_mouse(3,&dummy);
  3736.         dflag = TRUE;
  3737.         break;
  3738.     }
  3739.       }
  3740.  
  3741.       if(dflag)
  3742.       {
  3743.     oldx = mx;
  3744.     oldy = my;
  3745.     
  3746.         gsx_moff();
  3747.         do_outline(xor_handle,pxy);
  3748.         (*adj_mouse[pos])();        /* shift mouse */
  3749.     Supexec(KICKAES);
  3750.     do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3751.     gsx_mon();
  3752.  
  3753.         mbutton = TRUE;
  3754.     while(mbutton)
  3755.         {
  3756.        graf_mkstate(&newx,&newy,&mbutton,&dummy);
  3757.            if((oldx != newx) || (oldy != newy))
  3758.            {
  3759.         gsx_moff();
  3760.         do_rule_mark();
  3761.          do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3762.         (*da_box[pos])();
  3763.          do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3764.         gsx_mon();
  3765.        }
  3766.        oldx = newx;
  3767.        oldy = newy;
  3768.         }
  3769.  
  3770.     graf_mouse(2,&dummy);
  3771.     if(pxy[2] < pxy[0])       /* if x2 < x1 then swap */
  3772.     {
  3773.        temp = pxy[0];
  3774.        pxy[0] = pxy[2];
  3775.        pxy[2] = temp;
  3776.     }
  3777.         if(pxy[3] < pxy[1])
  3778.     {
  3779.        temp = pxy[1];
  3780.        pxy[1] = pxy[3];
  3781.        pxy[3] = temp;
  3782.     }
  3783.     
  3784.      if(snap_to_grids)
  3785.     {
  3786.         snap_to_grid(&pxy[0],&pxy[1]);
  3787.         snap_to_grid(&pxy[2],&pxy[3]);
  3788.     }
  3789.  
  3790.         gsx_moff();
  3791.         (*bdj_mouse[pos])();        /* shift mouse */
  3792.         if(*gcurx < 0) *gcurx = 0;
  3793.      if(*gcurx >= sxres) *gcurx = sxres - 1;
  3794.         if(*gcury < 0) *gcury = 0;
  3795.           if(*gcury >= syres) *gcury = syres - 1;
  3796.         Supexec(KICKAES);
  3797.     gsx_mon();
  3798.  
  3799.     region_ptr = ((gl_region_ptr) ? (gl_region_ptr):(gl_grregion_ptr));
  3800.     find_page(region_ptr,&page);
  3801.     alt_offset = (((page % 2) && (view_size == PADJCNT))?(TRUE):(FALSE));
  3802.     
  3803.     scrn2mu(tpxy[0],tpxy[1],&old_murect[0],&old_murect[1],0,alt_offset);
  3804.     scrn2mu(tpxy[2],tpxy[3],&old_murect[2],&old_murect[3],0,alt_offset);
  3805.     scrn2mu(pxy[0],pxy[1],&new_murect[0],&new_murect[1],0,alt_offset);
  3806.     scrn2mu(pxy[2],pxy[3],&new_murect[2],&new_murect[3],0,alt_offset);
  3807.  
  3808.     if((voldx != newx) || (voldy != newy))
  3809.     {
  3810.      /* modify primitive to new data coordinates */       
  3811.      old_width  = old_murect[2] - old_murect[0] + 1;
  3812.      old_height = old_murect[3] - old_murect[1] + 1;
  3813.  
  3814.      new_width  = new_murect[2] - new_murect[0];
  3815.      new_height = new_murect[3] - new_murect[1];
  3816.  
  3817.      topcode = opcode = get_cur_prim(&pcount,&wmode,&prim_ptr);
  3818.      if(opcode != -1)
  3819.      {
  3820.            switch(opcode)
  3821.            {
  3822.          case 0: 
  3823.          case 3:
  3824.          case 4:
  3825.             i=0;
  3826.             while(i<pcount*2)
  3827.             {
  3828.                odeltax = ptsarray[i] - old_murect[0];
  3829.                ndeltax = scale_iv(odeltax,new_width,
  3830.                 old_width); 
  3831.                ptsarray[i++] = new_murect[0] + ndeltax;
  3832.                    odeltay = ptsarray[i] - old_murect[1];
  3833.                ndeltay = scale_iv(odeltay,new_height,
  3834.                 old_height);
  3835.                ptsarray[i++] = new_murect[1] + ndeltay;
  3836.             }
  3837.             break;
  3838.  
  3839.         case 1: case12_scale(old_murect[0],
  3840.                      old_murect[1],
  3841.                      old_width,old_height,
  3842.                      new_murect[0],
  3843.                      new_murect[1],
  3844.                      new_width,
  3845.                      new_height,1);
  3846.             break;
  3847.  
  3848.         case 2: case12_scale(old_murect[0],
  3849.                      old_murect[1],
  3850.                      old_width,old_height,
  3851.                      new_murect[0],
  3852.                      new_murect[1],
  3853.                      new_width,
  3854.                      new_height,2);
  3855.             break;
  3856.            }
  3857.            post_edit_prim(opcode,pcount,wmode,prim_ptr);
  3858.      }
  3859.     }
  3860.       }
  3861.    graf_mouse(0,&dummy);    
  3862.    return(dflag);
  3863. }
  3864.  
  3865.  
  3866.  
  3867.  
  3868.  
  3869. /**************************************************************************/
  3870. /* Function: recalc_region()                          */
  3871. /* Description: Calculate region boundary after editing primitive      */
  3872. /**************************************************************************/
  3873. recalc_region()
  3874. {
  3875.    register int opcode;
  3876.    int fflag;
  3877.    int pcount;
  3878.  
  3879.    opcode = get_fprimitive(region_ptr,&pcount,&wmode);
  3880.    fflag = TRUE;
  3881.    while(opcode != -1)
  3882.    {
  3883.       calc_newbounds(fflag,opcode,pcount);
  3884.       opcode = get_nprimitive(&pcount,&wmode);
  3885.       fflag = FALSE;
  3886.    }    
  3887. }
  3888.  
  3889.  
  3890.  
  3891.  
  3892.  
  3893. /**************************************************************************/
  3894. /* Function: move_prim_box()                          */
  3895. /* Description: move a primitive within a region              */
  3896. /**************************************************************************/
  3897. move_prim_box(mx,my)
  3898. int mx,my;
  3899. {
  3900.     int opcode;
  3901.     int mbutton;
  3902.     int fx,fy;
  3903.     register int i;
  3904.     int tempx,tempy;
  3905.     int toggle;
  3906.     int minx,miny,maxx,maxy;
  3907.     int topcode;
  3908.     int pcount;
  3909.     int line_flag;
  3910.  
  3911.     topcode = opcode = get_cur_prim(&pcount,&wmode,&prim_ptr);
  3912.     calc_prim(opcode,&minx,&miny,&maxx,&maxy,pcount);
  3913.  
  3914.     if(alt_offset)
  3915.     {
  3916.     minx += hpage_size;
  3917.     maxx += hpage_size;
  3918.     }
  3919.     mutoscrn(minx,miny,&pxy[0],&pxy[1],0);
  3920.     mutoscrn(maxx,maxy,&pxy[2],&pxy[3],0);
  3921.  
  3922.     voldx = oldx = mx;
  3923.     voldy = oldy = my;
  3924.  
  3925.     line_flag=(((pxy[0]==pxy[2])||(pxy[1]==pxy[3]))?(TRUE):(FALSE));
  3926.  
  3927.     graf_mouse(4,&dummy);
  3928.     gsx_moff();
  3929.     do_outline(xor_handle,pxy);
  3930.     if(line_flag)
  3931.     do_outer(xor_handle,pxy);
  3932.     else
  3933.     do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3934.     gsx_mon();
  3935.  
  3936.     mbutton = TRUE;
  3937.     while(mbutton)
  3938.     {
  3939.       graf_mkstate(&newx,&newy,&mbutton,&dummy);
  3940.       if((oldx != newx) || (oldy != newy))
  3941.       {
  3942.      gsx_moff();
  3943.          do_rule_mark();
  3944.          if(line_flag)
  3945.         do_outer(xor_handle,pxy);
  3946.          else
  3947.         do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3948.  
  3949.      pxy[0] += newx - oldx;
  3950.          pxy[1] += newy - oldy;
  3951.          pxy[2] += newx - oldx;
  3952.          pxy[3] += newy - oldy;
  3953.          if(line_flag)
  3954.            do_outer(xor_handle,pxy);
  3955.          else
  3956.         do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  3957.  
  3958.      gsx_mon();
  3959.       }
  3960.       oldx = newx;
  3961.       oldy = newy;
  3962.     }
  3963.  
  3964.  
  3965.   if(check_dpwork_box(newx,newy))
  3966.   {
  3967.      if((voldx != newx) || (voldy != newy))
  3968.      {
  3969.        deltax = newx - voldx;
  3970.        deltay = newy - voldy;
  3971.  
  3972.        fx = ((deltax < 0) ? (-1) : (1));
  3973.        fy = ((deltay < 0) ? (-1) : (1));
  3974.  
  3975.        scrntomu(abs(newx - voldx),abs(newy - voldy),&deltax,&deltay,1);
  3976.  
  3977.        deltax *= fx;
  3978.        deltay *= fy;
  3979.  
  3980.        if(snap_to_grids)
  3981.        {
  3982.       tempx = deltax + minx;
  3983.       tempy = deltay + miny;
  3984.       snap_mu(&tempx,&tempy);
  3985.       deltax = tempx - minx;
  3986.       deltay = tempy - miny;
  3987.        }
  3988.  
  3989.        
  3990.     switch(opcode)
  3991.     {
  3992.         case 3:
  3993.         case 4:
  3994.         case 0: toggle = TRUE;
  3995.                 for(i=0;i<(pcount*2);i++)
  3996.             {
  3997.                ptsarray[i] += ((toggle) ? (deltax):(deltay));
  3998.                toggle ^= TRUE;
  3999.             }
  4000.             break;
  4001.  
  4002.         case 1: ptsarray[0] += deltax;
  4003.             ptsarray[1] += deltay;
  4004.             break;
  4005.  
  4006.         case 2: ptsarray[0] += deltax;
  4007.             ptsarray[2] += deltax;
  4008.             ptsarray[1] += deltay;
  4009.             ptsarray[3] += deltay;
  4010.             break;
  4011.        
  4012.     }    /* end of switch(opcode) */
  4013.  
  4014.         if(kstat & 0x0004)
  4015.     {
  4016.            copy_prim(opcode,pcount,wmode);
  4017.            return;
  4018.         }
  4019.  
  4020.         post_edit_prim(opcode,pcount,wmode,prim_ptr);
  4021.     }
  4022.     else
  4023.     {
  4024.        gsx_moff();
  4025.        do_outline(xor_handle,pxy);
  4026.        do_box(xor_handle,pxy[0],pxy[1],pxy[2],pxy[3]);
  4027.        gsx_mon();
  4028.  
  4029.     }
  4030.  }
  4031.  else
  4032.  {
  4033.    gsx_moff();
  4034.    do_blit();
  4035.    mutoscrn(minx,miny,&pxy[0],&pxy[1],0);
  4036.    mutoscrn(maxx,maxy,&pxy[2],&pxy[3],0);
  4037.    do_outline(xor_handle,pxy);
  4038.    gsx_mon();
  4039.  }
  4040.     graf_mouse(0,&dummy);
  4041. }
  4042.  
  4043.  
  4044.  
  4045. /**************************************************************************/
  4046. /* Function: inside_primitive()                            */
  4047. /* Description: Check if clicked within a primitive              */
  4048. /**************************************************************************/
  4049. inside_primitive(x,y)
  4050. int x,y;
  4051. {
  4052.    int opcode;
  4053.    int minx,miny,maxx,maxy;
  4054.    int pcount;
  4055.    int xoffset,yoffset;            /* Offset for 1 pixel of mu's */
  4056.    int temp;
  4057.  
  4058.    temp = alt_offset;
  4059.    scrntomu(2,2,&xoffset,&yoffset,1);
  4060.    alt_offset = temp;
  4061.  
  4062.    opcode = get_cur_prim(&pcount,&wmode,&prim_ptr);    
  4063.    calc_prim(opcode,&minx,&miny,&maxx,&maxy,pcount);
  4064.    if(minx == maxx || miny == maxy)
  4065.    {
  4066.         xoffset *= 3;
  4067.         yoffset *= 3;
  4068.    }
  4069.    if(x >= minx-xoffset && x <= maxx+xoffset &&
  4070.       y >= miny-yoffset && y <= maxy+yoffset)
  4071.     return 1;
  4072.    else
  4073.     return 0;
  4074. }
  4075.  
  4076.  
  4077.  
  4078. /**************************************************************************/
  4079. /*        Handle left icon panel selections              */
  4080. /**************************************************************************/
  4081. hndl_icons(obj)
  4082. int obj;
  4083. {
  4084.    int item;
  4085.    int title;
  4086.  
  4087.    if(ad_bkgrnd[obj].ob_state == DISABLED)
  4088.     return;
  4089.    if(bgicptr->bi_pdata == primicons)
  4090.    {
  4091.       switch(obj)
  4092.       {
  4093.     case ICBOX1:
  4094.         item = RCLOSE;
  4095.         title = TREGION;
  4096.         break;
  4097.  
  4098.     case ICBOX2:
  4099.            item = OPOLYGON;
  4100.         title = TOBJECTS;
  4101.         break;
  4102.  
  4103.     case ICBOX3:
  4104.               item = OCIRCLE;
  4105.         title = TOBJECTS;
  4106.         break;
  4107.  
  4108.     case ICBOX4:
  4109.         item = OELLIPSE;
  4110.         title = TOBJECTS;
  4111.         break;
  4112.  
  4113.     case ICBOX5:
  4114.         item = OBOX;
  4115.         title = TOBJECTS;
  4116.         break;
  4117.  
  4118.     case ICBOX6:
  4119.         item = OLINE;
  4120.         title = TOBJECTS;
  4121.         break;
  4122.  
  4123.     case ICBOX7:
  4124.         item = ORBOX;
  4125.         title = TOBJECTS;
  4126.         break;
  4127.  
  4128.     case ICBOX8:
  4129.         item = OIMAGE;
  4130.         title = TOBJECTS;
  4131.         break;
  4132.  
  4133.     default:
  4134.         item = 0;
  4135.         title = 0;
  4136.         break;
  4137.     }
  4138.    }
  4139.    else
  4140.    {
  4141.       switch(obj)
  4142.       {
  4143.     case ICBOX1:
  4144.            item = RCREATE;
  4145.         title = TREGION;
  4146.         break;
  4147.  
  4148.     case ICBOX2:
  4149.               item = ROPENGR;
  4150.         title = TREGION;
  4151.         break;
  4152.  
  4153.     case ICBOX3:
  4154.         item = RTOGGLE;
  4155.         title = TREGION;
  4156.         break;
  4157.  
  4158.     case ICBOX4:
  4159.         item = RDIMAGES;
  4160.         title = TREGION;
  4161.         break;
  4162.  
  4163.     case ICBOX5:
  4164.         item = FNEW;
  4165.         title = TFILE;
  4166.         break;
  4167.  
  4168.     case ICBOX6:
  4169.         item = FPRINT;
  4170.         title = TFILE;
  4171.         break;
  4172.  
  4173.     case ICBOX7:
  4174.         item = OSHOWGR;
  4175.         title = TOPTIONS;
  4176.         break;
  4177.  
  4178.     case ICBOX8:
  4179.         item = OSNAP;
  4180.         title = TOPTIONS;
  4181.         break;
  4182.  
  4183.     default:
  4184.         item = 0;
  4185.         title = 0;
  4186.         break;
  4187.     }
  4188.    }
  4189.  
  4190.    if(item && !(ad_menu[item].ob_state & DISABLED)
  4191.        && !(ad_menu[title].ob_state & DISABLED))
  4192.    {
  4193.     menu_handler(1,item);
  4194.    }
  4195. }
  4196.     
  4197. change_icstate(state,obj,redraw_flag)
  4198. int state;
  4199. int obj;
  4200. int redraw_flag;
  4201. {
  4202.    int x,y;
  4203.    ad_bkgrnd[obj].ob_state = state;
  4204.    if(redraw_flag)
  4205.    {
  4206.       objc_offset(ad_bkgrnd,obj,&x,&y);
  4207.       form_dial(3,0,0,0,0,x,y,
  4208.       ad_bkgrnd[obj].ob_width,
  4209.       ad_bkgrnd[obj].ob_height); 
  4210.    }
  4211. }
  4212.  
  4213. clr_bgicons(redraw_flag)
  4214. int redraw_flag;
  4215. {
  4216.    register int i;
  4217.  
  4218.    for(i = ICBOX1;i <= ICBOX8;i++)
  4219.       if(ad_bkgrnd[i].ob_state == SELECTED)
  4220.       change_icstate(NORMAL,i,redraw_flag);
  4221. }      
  4222.  
  4223.  
  4224.  
  4225.  
  4226.  
  4227. do_template_edit()
  4228. {
  4229.    int titem;
  4230.  
  4231.    tmplate_flag ^= TRUE;
  4232.  
  4233.    menu_text(ad_menu,OEDITTMP,template_mode[tmplate_flag]);
  4234.    if(tmplate_flag)            /* now editing templates     */
  4235.    {
  4236. /*     wind_set(prev_handle,WF_NAME," Base Page Window ",0,0);*/
  4237.      wind_set(prev_handle,WF_NAME,basefname,0,0);
  4238.       menu_ienable(ad_menu,OERASETP,TRUE);
  4239.      menu_ienable(ad_menu,PGOTO,FALSE);
  4240.      menu_ienable(ad_menu,PDELETE,FALSE);
  4241.      menu_ienable(ad_menu,PINSERT,FALSE);
  4242.      tpagehd = pagehd;
  4243.      tcurpage = curpage;
  4244.      temp_page = curr_page;
  4245.      tarthd = arthd;
  4246.      tcurart = curart;     
  4247.  
  4248.      curr_page = right_tmplate->pagenum;
  4249.      pagehd = curpage = right_tmplate;
  4250.      do_pagenum(curr_page,(curr_page%2)?1:0);
  4251.      curart = arthd = ((curr_page % 2)?(rtarthd):(ltarthd));
  4252.  
  4253.      if(view_size == PADJCNT)
  4254.      {
  4255.        titem = ((curr_page % 2) ? (PADJCNT + 1) : (PADJCNT));
  4256.        wind_set(prev_handle,WF_INFO,winfo[titem - PSIZE][unit_type]);       
  4257.      }
  4258.  
  4259.    }
  4260.    else                    /* Now editing preview buffers  */
  4261.    {
  4262.      wind_set(prev_handle,WF_NAME,pfname,0,0);
  4263.      menu_ienable(ad_menu,OERASETP,FALSE);
  4264.      menu_ienable(ad_menu,PGOTO,TRUE);
  4265.      menu_ienable(ad_menu,PDELETE,TRUE);
  4266.      menu_ienable(ad_menu,PINSERT,TRUE);
  4267.  
  4268.      if(curr_page == -2)
  4269.         ltarthd = arthd;
  4270.      else
  4271.         rtarthd = arthd;
  4272.     
  4273.      curart = tcurart;
  4274.      arthd  = tarthd;
  4275.      pagehd = tpagehd;
  4276.      curpage = tcurpage;
  4277.      curr_page = temp_page;
  4278.      do_pagenum(curr_page,(curr_page%2)?1:0);
  4279.      if(view_size == PADJCNT)
  4280.      {
  4281.        titem = ((curr_page % 2) ? (PADJCNT + 1) : (PADJCNT));
  4282.        wind_set(prev_handle,WF_INFO,winfo[titem - PSIZE][unit_type]);       
  4283.      }
  4284.    }
  4285.    force_preview();
  4286. }
  4287.  
  4288.  
  4289. /* clears only one template */
  4290. erase_template()
  4291. {
  4292.    if(alert_cntre(ALERT27) == 1)
  4293.    {
  4294.      if(pagehd  == right_tmplate)
  4295.           free_right_tmplate();
  4296.      else
  4297.           free_left_tmplate();
  4298.      strcpy(basefname," Base Page Window ");
  4299.      wind_set(prev_handle,WF_NAME,basefname,0,0);
  4300.      force_preview();
  4301.    }
  4302. }
  4303.  
  4304.  
  4305.  
  4306. /* clears both templates*/
  4307. delete_tmplates()
  4308. {
  4309.    strcpy(basefname," Base Page Window ");
  4310.    free_templates();
  4311.    init_templates();
  4312. }
  4313.  
  4314.  
  4315.  
  4316. init_templates()
  4317. {
  4318. /*   tmplate_flag = FALSE;        * Set to Edit Preview       */
  4319.  
  4320.    left_tmplate  = (PAGE *)get_lcmem((long)sizeof(PAGE));
  4321.    right_tmplate = (PAGE *)get_lcmem((long)sizeof(PAGE));
  4322.  
  4323.    left_tmplate->pagenum = -2;        /* left page */
  4324.    right_tmplate->pagenum = -1;        /* right page */
  4325.    
  4326.    left_tmplate->nextpage = NULLPTR;
  4327.    right_tmplate->nextpage = NULLPTR;
  4328.    
  4329.    ltarthd = 0L;
  4330.    rtarthd = 0L;
  4331. }
  4332.  
  4333.  
  4334.  
  4335. free_templates()
  4336. {
  4337.    PAGE *rpagehd;
  4338.    PAGE *rcurpage;
  4339.    int  dummy;
  4340.    ARTICLE *art;
  4341.    ARTICLE *rarthd;
  4342.    ARTICLE *rcurart;
  4343.    int rcurr_page;
  4344.  
  4345.    rpagehd = pagehd;
  4346.    rcurpage = curpage;
  4347.    rcurr_page = curr_page;
  4348.    rarthd = arthd;
  4349.    rcurart = curart;
  4350.  
  4351.    pagehd = curpage = left_tmplate;
  4352.    get_fpage(&dummy);
  4353.    while(delete_page());
  4354.  
  4355.    pagehd = curpage = right_tmplate;
  4356.    get_fpage(&dummy);
  4357.    while(delete_page());
  4358.    arthd = ltarthd;
  4359.    art = getf_article();
  4360.    while(delete_article());
  4361.    
  4362.    arthd = rtarthd;
  4363.    art = getf_article();
  4364.    while(delete_article());
  4365.  
  4366.    
  4367.    ltarthd = rtarthd = 0L;    /* CJG */
  4368.  
  4369.    pagehd = rpagehd;
  4370.    curpage = rcurpage;
  4371.    arthd = rarthd;
  4372.    curart = rcurart;
  4373.    curr_page = rcurr_page;
  4374.  
  4375. }
  4376.  
  4377.  
  4378. free_right_tmplate()
  4379. {
  4380.     ARTICLE *art;
  4381.     int dummy;
  4382.  
  4383.     get_fpage(&dummy);
  4384.     while(delete_page());
  4385.  
  4386.     right_tmplate  = (PAGE *)get_lcmem((long)sizeof(PAGE));    
  4387.     right_tmplate->pagenum = -1;        /* right page */
  4388.     right_tmplate->nextpage = NULLPTR;
  4389.  
  4390.     art = getf_article();
  4391.     while(delete_article());
  4392.     rtarthd = 0L;
  4393.  
  4394.     pagehd = curpage = right_tmplate;
  4395.     curr_page = -1;
  4396. }
  4397.  
  4398.  
  4399.  
  4400.  
  4401. free_left_tmplate()
  4402. {
  4403.     ARTICLE *art;
  4404.     int dummy;
  4405.  
  4406.     get_fpage(&dummy);
  4407.     while(delete_page());
  4408.  
  4409.     left_tmplate  = (PAGE *)get_lcmem((long)sizeof(PAGE));    
  4410.     left_tmplate->pagenum = -2;        /* left page */
  4411.     left_tmplate->nextpage = NULLPTR;
  4412.  
  4413.     art = getf_article();
  4414.     while(delete_article());
  4415.     ltarthd = 0L;
  4416.     pagehd = curpage = left_tmplate;
  4417.     curr_page = -2;
  4418. }
  4419.  
  4420.  
  4421.  
  4422.  
  4423. copy_region()
  4424. {
  4425.    int opcode;
  4426.    REGION *new_region;
  4427.    REGION *old_region;
  4428.    int type;
  4429.    PRIMITIVE *tprim;
  4430.    int toggle;
  4431.    register int i;
  4432.    int page;
  4433.    int rectmu[4];
  4434.    int tmulti;
  4435.  
  4436.    rcopy_flag = FALSE;
  4437.  
  4438.    old_region = get_curreg(&type);
  4439.  
  4440.    if(!type)
  4441.        get_txtattr(old_region,&gltxtattr);
  4442.    else
  4443.         get_grattr(old_region,glgrattr);
  4444.    
  4445.  
  4446.    curregion = new_region = create_region(curr_page,type);
  4447.    if(!type)
  4448.     put_txtattr(curregion,&gltxtattr);
  4449.    else
  4450.         put_grattr(curregion,glgrattr);
  4451.  
  4452.    
  4453.    opcode = get_fprimitive(old_region,&count,&wmode);
  4454.    
  4455.    while(opcode != -1)
  4456.    {
  4457.        switch(opcode)
  4458.        {
  4459.          case 3:
  4460.          case 4:
  4461.          case 0: toggle = TRUE;
  4462.          for(i=0;i<(count*2);i++)
  4463.          {
  4464.            ptsarray[i] += ((toggle) ?(deltax):(deltay));
  4465.            toggle ^= TRUE;
  4466.                  }
  4467.                break;
  4468.  
  4469.          case 1: ptsarray[0] += deltax;
  4470.                  ptsarray[1] += deltay;
  4471.          break;
  4472.  
  4473.          case 2: ptsarray[0] += deltax;
  4474.                  ptsarray[2] += deltax;
  4475.                  ptsarray[1] += deltay;
  4476.          ptsarray[3] += deltay;
  4477.          break;
  4478.        }
  4479.  
  4480.        tprim = curprim;
  4481.        switch(opcode)
  4482.        {
  4483.       case 3:
  4484.       case 4:
  4485.       case 0: 
  4486.       case 2: put_poly(opcode,count,wmode,type);
  4487.           break;
  4488.  
  4489.           case 1: put_ellipse(wmode,type);
  4490.           break;
  4491.        }
  4492.        
  4493.        curprim = tprim;
  4494.        opcode = get_nprimitive(&count,&wmode);
  4495.    }
  4496.    graf_mouse(ARROW,&dummy);
  4497.  
  4498.  
  4499.    curregion = region_ptr = new_region;
  4500.  
  4501.    if(type)
  4502.        gl_grregion_ptr = new_region;
  4503.    else
  4504.        gl_region_ptr = new_region;
  4505.  
  4506.  
  4507.    find_boundary(region_ptr,
  4508.                  &rect_in_mu[0],&rect_in_mu[1],
  4509.                  &rect_in_mu[2],&rect_in_mu[3],&dummy,&page);
  4510.  
  4511.    rectmu[0] = rect_in_mu[0];
  4512.    rectmu[1] = rect_in_mu[1];
  4513.    rectmu[2] = rect_in_mu[2];
  4514.    rectmu[3] = rect_in_mu[3];
  4515.  
  4516.  
  4517.    tmulti = multi_mode;
  4518.    if(!type)
  4519.     page_redraw(region_ptr);
  4520.    else
  4521.     update_repel(1,rect_in_mu);
  4522.  
  4523.    if(view_size != PADJCNT && !deferhj && gl_region_ptr)
  4524.         redraw_area(region_ptr,rect_in_mu,1);/* Cleanup old area */
  4525.  
  4526.    multi_mode = tmulti;
  4527.    rect_in_mu[0] = rectmu[0];
  4528.    rect_in_mu[1] = rectmu[1];
  4529.    rect_in_mu[2] = rectmu[2];
  4530.    rect_in_mu[3] = rectmu[3];
  4531.  
  4532.    curregion = region_ptr = new_region;
  4533.    if(!type)                    /* cjg 01/31/89 */
  4534.          gl_region_ptr = region_ptr;
  4535.    else
  4536.      gl_grregion_ptr = region_ptr;
  4537.  
  4538.    if((page % 2) && (view_size == PADJCNT))
  4539.    {
  4540.       alt_offset = TRUE;
  4541.       rect_in_mu[0] += hpage_size;
  4542.       rect_in_mu[2] += hpage_size;
  4543.    }
  4544.    mutoscrn(rect_in_mu[0],rect_in_mu[1],&pxy[0],&pxy[1],0);
  4545.    mutoscrn(rect_in_mu[2],rect_in_mu[3],&pxy[2],&pxy[3],0);
  4546.    if(!multi_mode)
  4547.    {
  4548.       gsx_moff();
  4549.       do_outline(xor_handle,pxy);
  4550.       gsx_mon();
  4551.    }
  4552. }
  4553.  
  4554.  
  4555.  
  4556.  
  4557. copy_prim(opcode,count,wmode)
  4558. int opcode;
  4559. int count;
  4560. int wmode;
  4561. {
  4562.    int type;
  4563.    REGION *tregion;
  4564.    int oldrect[4];
  4565.    int dummy;
  4566.    long prim_ptr;
  4567.    int minx,miny,maxx,maxy;
  4568.  
  4569.    tregion = get_curreg(&type);
  4570.  
  4571.    switch(opcode)
  4572.    {
  4573.       case 3:
  4574.       case 4:
  4575.       case 0: 
  4576.       case 2: put_poly(opcode,count,wmode,type);
  4577.                break;
  4578.  
  4579.       case 1: put_ellipse(wmode,type);
  4580.           break;
  4581.    }
  4582.    get_cur_prim(&count,&wmode,&prim_ptr);
  4583.  
  4584.    region_ptr = tregion;
  4585.  
  4586.    find_boundary(tregion,&oldrect[0],&oldrect[1],&oldrect[2],
  4587.              &oldrect[3],&dummy,&dummy);
  4588.  
  4589.    if(!type)
  4590.    {
  4591.       page_redraw(region_ptr);
  4592.       gl_region_ptr = tregion;
  4593.    }
  4594.    else
  4595.    {
  4596.       update_repel(1,oldrect);
  4597.       gl_grregion_ptr = tregion;
  4598.    }
  4599.    region_ptr = tregion;
  4600.    active_prim = TRUE;
  4601.    open_region(region_ptr);
  4602.    recalc_region();
  4603.    set_cur_prim(prim_ptr);
  4604.    calc_prim(opcode,&minx,&miny,&maxx,&maxy,count);   
  4605.    outline_primman(minx,miny,maxx,maxy,type,curr_page);
  4606.    graf_mouse(ARROW,&dummy);
  4607. }
  4608.  
  4609.  
  4610.  
  4611. check_dpwork_box(mx,my)
  4612. int mx,my;
  4613. {
  4614.     int x1,y1,x2,y2;
  4615.  
  4616.     y1 = dpwork.g_y;
  4617.     y2 = dpwork.g_y + dpwork.g_h - 1;
  4618.  
  4619.     if(view_size == PADJCNT)
  4620.     {
  4621.       if(curr_page % 2)
  4622.       {                /* right side of alternate pages */
  4623.          x1 = dpwork.g_x + (dpwork.g_w/2);
  4624.          x2 = dpwork.g_x + dpwork.g_w - 1;
  4625.       }
  4626.       else
  4627.       {                /* left side of alternate pages  */
  4628.          x1 = dpwork.g_x;
  4629.          x2 = dpwork.g_x + (dpwork.g_w/2) - 1;
  4630.       }
  4631.     }
  4632.     else
  4633.     {
  4634.       x1 = dpwork.g_x;
  4635.       x2 = dpwork.g_x + dpwork.g_w - 1;
  4636.     }
  4637.  
  4638.     if(((mx > x1) && (mx < x2)) &&
  4639.       ((my > y1) && (my < y2)))
  4640.             return(1);
  4641.     else
  4642.        return(0);
  4643. }
  4644.